endoreg-db 0.8.5.3__py3-none-any.whl → 0.8.5.5__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/models/metadata/sensitive_meta_logic.py

@@ -765,17 +765,37 @@ def update_sensitive_meta_from_dict(
         k: v for k, v in data.items() if k in field_names and k not in excluded_fields
     }
 
-    # Handle potential Center update
+    # Handle potential Center update - accept both center_name (string) and center (object)
+    from ..administration import Center
+
+    center = data.get("center")  # First try direct Center object
     center_name = data.get("center_name")
-    if center_name:
+
+    if center is not None:
+        # Center object provided directly - validate and update
+        if isinstance(center, Center):
+            instance.center = center
+            logger.debug(f"Updated center from Center object: {center.name}")
+        else:
+            logger.warning(
+                f"Invalid center type {type(center)}, expected Center instance. Ignoring."
+            )
+        # Remove from selected_data to prevent override
+        selected_data.pop("center", None)
+    elif center_name:
+        # center_name string provided - resolve to Center object
         try:
-            center = Center.objects.get(name=center_name)
-            instance.center = center  # Update center directly
+            center_obj = Center.objects.get(name=center_name)
+            instance.center = center_obj
+            logger.debug(f"Updated center from center_name string: {center_name}")
         except Center.DoesNotExist:
             logger.warning(
                 f"Center '{center_name}' not found during update. Keeping existing center."
             )
-            selected_data.pop("center", None)  # Remove from dict if not found
+    else:
+        # Both are None/missing - remove 'center' from selected_data to preserve existing value
+        selected_data.pop("center", None)
+    # If both are None/missing, keep existing center (no update needed)
 
     # Set examiner names if provided, before calling save
     examiner_first_name = data.get("examiner_first_name")
@@ -858,6 +878,11 @@ def update_sensitive_meta_from_dict(
     # Update other attributes from selected_data
     patient_name_changed = False
     for k, v in selected_data.items():
+        # Skip None values to avoid overwriting existing data
+        if v is None:
+            logger.debug(f"Skipping field '{k}' during update because value is None")
+            continue
+
         # Avoid overwriting examiner names if they were just explicitly set
         if (
             k not in ["examiner_first_name", "examiner_last_name"]

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

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