endoreg-db 0.8.4.4__py3-none-any.whl → 0.8.6.1__py3-none-any.whl

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/misc/__init__.py

@@ -1,5 +1,5 @@
 from .file_overview import FileOverviewSerializer
-from .vop_patient_data import VoPPatientDataSerializer
+from .sensitive_patient_data import VoPPatientDataSerializer
 from .stats import StatsSerializer
 from .upload_job import UploadJobStatusSerializer, UploadCreateResponseSerializer
 from .translatable_field_mix_in import TranslatableFieldMixin

endoreg_db/serializers/misc/file_overview.py

@@ -1,12 +1,19 @@
-from rest_framework import serializers
 from typing import TYPE_CHECKING
-from endoreg_db.models.media import VideoFile, RawPdfFile
-from endoreg_db.models.state.video import AnonymizationStatus as VideoAnonymizationStatus
-from endoreg_db.models.state.raw_pdf import AnonymizationStatus as PdfAnonymizationStatus
+
+from rest_framework import serializers
+
+from endoreg_db.models.media import RawPdfFile, VideoFile
+from endoreg_db.models.state.raw_pdf import (
+    AnonymizationStatus as PdfAnonymizationStatus,
+)
+from endoreg_db.models.state.video import (
+    AnonymizationStatus as VideoAnonymizationStatus,
+)
 
 if TYPE_CHECKING:
     pass
 
+
 class FileOverviewSerializer(serializers.Serializer):
     """
     Polymorphic "union" serializer – we normalise both model types
@@ -22,75 +29,81 @@ class FileOverviewSerializer(serializers.Serializer):
     annotationStatus = serializers.CharField(read_only=True)
     createdAt = serializers.DateTimeField(read_only=True)
     text = serializers.CharField(required=False, allow_blank=True, read_only=True)
-    anonymizedText = serializers.CharField(required=False, allow_blank=True, read_only=True)
+    anonymizedText = serializers.CharField(
+        required=False, allow_blank=True, read_only=True
+    )
 
     # --- converting DB objects to that shape -----------------------
     def to_representation(self, instance):
         """
         Return a unified dictionary representation of either a VideoFile or RawPdfFile instance for front-end use.
-        
+
         For VideoFile instances, extracts and structures metadata such as patient, examination, equipment, and examiner information, and generates an anonymized version of the text by replacing sensitive fields with placeholders. For RawPdfFile instances, extracts text and anonymized text directly and determines statuses based on available fields.
-        
+
         Parameters:
             instance: A VideoFile or RawPdfFile object to be serialized.
-        
+
         Returns:
             dict: A normalized dictionary containing id, filename, mediaType, anonymizationStatus, annotationStatus, createdAt, text, and anonymizedText fields.
-        
+
         Raises:
             TypeError: If the instance is not a VideoFile or RawPdfFile.
         """
         text = ""
         anonym_text = ""
-        
+
         if isinstance(instance, VideoFile):
             media_type = "video"
             created_at = instance.uploaded_at
             filename = instance.original_file_name or (
-                instance.raw_file.name.split("/")[-1] if instance.raw_file else "unknown"
+                instance.raw_file.name.split("/")[-1]
+                if instance.raw_file
+                else "unknown"
             )
-            
+
             # ------- anonymization status using VideoState model
             vs = instance.state
-            anonym_status = vs.anonymization_status if vs else VideoAnonymizationStatus.NOT_STARTED
-            
+            anonym_status = (
+                vs.anonymization_status if vs else VideoAnonymizationStatus.NOT_STARTED
+            )
+
             # ------- annotation status (validated label segments)
             if instance.label_video_segments.filter(state__is_validated=True).exists():
                 annot_status = "done"
             else:
                 annot_status = "not_started"
-            
+
             # ------- Extract text from sensitive_meta for videos
             if instance.sensitive_meta:
                 sm = instance.sensitive_meta
                 # Create a structured text representation from sensitive meta
                 text_parts = []
-                
+
                 # Patient information
                 if sm.patient_first_name or sm.patient_last_name:
                     patient_name = f"{sm.patient_first_name or ''} {sm.patient_last_name or ''}".strip()
                     text_parts.append(f"Patient: {patient_name}")
-                
+
                 if sm.patient_dob:
                     text_parts.append(f"Date of Birth: {sm.patient_dob.date()}")
-                
+
                 if sm.patient_gender:
                     text_parts.append(f"Gender: {sm.patient_gender}")
-                
+
                 # Examination information
                 if sm.examination_date:
                     text_parts.append(f"Examination Date: {sm.examination_date}")
-                
+
                 if sm.center:
                     text_parts.append(f"Center: {sm.center.name}")
-                
+
                 # Equipment information
                 if sm.endoscope_type:
                     text_parts.append(f"Endoscope Type: {sm.endoscope_type}")
-                
+
                 if sm.endoscope_sn:
                     text_parts.append(f"Endoscope SN: {sm.endoscope_sn}")
-                
+
                 # Examiner information
                 if sm.pk:  # Only if saved
                     try:
@@ -100,39 +113,56 @@ class FileOverviewSerializer(serializers.Serializer):
                             text_parts.append(f"Examiners: {examiner_names}")
                     except Exception:
                         pass  # Ignore examiner lookup errors
-                
+
                 text = "\n".join(text_parts)
-                
+
                 # Create anonymized version by replacing sensitive data
                 anonym_text = text
                 if sm.patient_first_name:
-                    anonym_text = anonym_text.replace(sm.patient_first_name, "[FIRST_NAME]")
+                    anonym_text = anonym_text.replace(
+                        sm.patient_first_name, "[FIRST_NAME]"
+                    )
                 if sm.patient_last_name:
-                    anonym_text = anonym_text.replace(sm.patient_last_name, "[LAST_NAME]")
+                    anonym_text = anonym_text.replace(
+                        sm.patient_last_name, "[LAST_NAME]"
+                    )
                 if sm.patient_dob:
-                    anonym_text = anonym_text.replace(str(sm.patient_dob.date()), "[DOB]")
+                    anonym_text = anonym_text.replace(
+                        str(sm.patient_dob.date()), "[DOB]"
+                    )
                 if sm.endoscope_sn:
                     anonym_text = anonym_text.replace(sm.endoscope_sn, "[ENDOSCOPE_SN]")
-                
+
                 # Replace examiner names if available
                 if sm.pk:
                     try:
                         examiners = list(sm.examiners.all())
                         for examiner in examiners:
-                            anonym_text = anonym_text.replace(str(examiner), "[EXAMINER]")
+                            anonym_text = anonym_text.replace(
+                                str(examiner), "[EXAMINER]"
+                            )
                     except Exception:
                         pass
 
         elif isinstance(instance, RawPdfFile):
-            instance:RawPdfFile
+            instance: RawPdfFile
             media_type = "pdf"
             created_at = instance.date_created
             filename = instance.file.name.split("/")[-1] if instance.file else "unknown"
-            # Check anonymized_text field
-            anonym_status = "done" if (instance.anonymized_text and instance.anonymized_text.strip()) else "not_started"
+
+            # ------- anonymization status using RawPdfState model (like VideoFile)
+            ps = instance.state
+            anonym_status = (
+                ps.anonymization_status if ps else PdfAnonymizationStatus.NOT_STARTED
+            )
+
             # PDF annotation == "sensitive meta validated"
-            annot_status = "done" if getattr(instance.sensitive_meta, "is_verified", False) else "not_started"
-            
+            annot_status = (
+                "done"
+                if getattr(instance.sensitive_meta, "is_verified", False)
+                else "not_started"
+            )
+
             # Extract text content from PDF
             text = instance.text or ""
             anonym_text = instance.anonymized_text or ""

endoreg_db/serializers/misc/{vop_patient_data.py → sensitive_patient_data.py}

@@ -80,7 +80,7 @@ class VoPPatientDataSerializer(serializers.Serializer):
 
         elif isinstance(instance, RawPdfFile):
             # Generate PDF streaming URL using pdf_id (RawPdfFile.id)
-            pdf_stream_url = f"/api/pdfstream/{instance.pk}/"
+            pdf_stream_url = f"/api/media/pdfs/{instance.pk}/stream/"
             
             return {
                 "id": instance.pk,

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