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

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/services/anonymization.py

@@ -1,31 +1,33 @@
 # endoreg_db/services/anonymization.py
+import logging
 from pathlib import Path
+from typing import Optional
+
 from django.db import transaction
-from django.conf import settings
-from endoreg_db.models import VideoFile, RawPdfFile
-from endoreg_db.services.video_import import VideoImportService
+
+from endoreg_db.models import RawPdfFile, VideoFile
 from endoreg_db.services.pdf_import import PdfImportService
+from endoreg_db.services.video_import import VideoImportService
 from endoreg_db.utils.paths import STORAGE_DIR
-import logging
+from endoreg_db.utils.storage import ensure_local_file, file_exists
 
 logger = logging.getLogger(__name__)
 
+
 class AnonymizationService:
     """
     Orchestrates long‑running anonymization tasks so the view only
     does HTTP <-> Service translation.
     """
-    
-    def __init__(self, project_root: Path = None):
+
+    def __init__(self, project_root: Optional[Path] = None):
         """
         Initialize the AnonymizationService with service instances.
-        
+
         Args:
             project_root: Path to the project root. If None, uses settings.BASE_DIR
         """
-        if project_root is None:
-            project_root = STORAGE_DIR
-        
+        self.project_root: Path = project_root or STORAGE_DIR
         self.video_service = VideoImportService()
         self.pdf_service = PdfImportService()
 
@@ -34,7 +36,7 @@ class AnonymizationService:
     def get_status(file_id: int):
         """
         Retrieve the anonymization status and media type for a file by its ID.
-        
+
         Returns:
             dict or None: A dictionary containing the file's media type and anonymization status if found, or None if no matching file exists.
         """
@@ -43,7 +45,7 @@ class AnonymizationService:
             return {
                 "mediaType": "video",
                 "anonymizationStatus": vf.state.anonymization_status if vf.state else "not_started",
-                "fileExists": bool(vf.raw_file and hasattr(vf.raw_file, 'path')),
+                "fileExists": file_exists(vf.raw_file),
                 "uuid": str(vf.uuid) if vf.uuid else None,
             }
 
@@ -52,7 +54,7 @@ class AnonymizationService:
             return {
                 "mediaType": "pdf",
                 "anonymizationStatus": pdf.state.anonymization_status if pdf.state else "not_started",
-                "fileExists": bool(pdf.file and hasattr(pdf.file, 'path')),
+                "fileExists": file_exists(pdf.file),
                 "hash": pdf.pdf_hash,
             }
         return None
@@ -62,10 +64,10 @@ class AnonymizationService:
     def start(self, file_id: int):
         """
         Start anonymization process for a file by its ID.
-        
+
         Args:
             file_id: The ID of the file to anonymize
-            
+
         Returns:
             str or None: Media type if successful, None if file not found
         """
@@ -74,45 +76,42 @@ class AnonymizationService:
         if vf:
             try:
                 logger.info(f"Starting video anonymization for VideoFile ID: {file_id}")
-                
+
                 # Check if already processed
                 if vf.state and vf.state.anonymized:
                     logger.info(f"VideoFile {file_id} already anonymized, skipping")
                     return "video"
-                
+
                 # Get file path
                 file_path = vf.get_raw_file_path()
                 if not file_path or not Path(file_path).exists():
                     logger.error(f"Raw file not found for VideoFile {file_id}: {file_path}")
                     return None
-                
+
                 # Get processor name
                 processor_name = None
                 if vf.video_meta and vf.video_meta.processor:
                     processor_name = vf.video_meta.processor.name
-                elif hasattr(vf, 'processor') and vf.processor:
+                elif hasattr(vf, "processor") and vf.processor:
                     processor_name = vf.processor.name
-                
+
                 # Get center name
                 center_name = vf.center.name if vf.center else "unknown_center"
-                
+
                 # Mark as started
                 if vf.state:
                     vf.state.processing_started = True
                     vf.state.save(update_fields=["processing_started"])
-                
+
                 # Use VideoImportService for anonymization
+                safe_processor_name = processor_name or "unknown_processor"
                 self.video_service.import_and_anonymize(
-                    file_path=file_path,
-                    center_name=center_name,
-                    processor_name=processor_name,
-                    save_video=True,
-                    delete_source=False
+                    file_path=file_path, center_name=center_name, processor_name=safe_processor_name, save_video=True, delete_source=False
                 )
-                
+
                 logger.info(f"Video anonymization completed for VideoFile ID: {file_id}")
                 return "video"
-                
+
             except Exception as e:
                 logger.error(f"Failed to anonymize VideoFile {file_id}: {e}")
                 # Mark as failed if state exists
@@ -126,51 +125,48 @@ class AnonymizationService:
         if pdf:
             try:
                 logger.info(f"Starting PDF processing for RawPdfFile ID: {file_id}")
-                
+
                 # Check if already processed
-                if pdf.state and getattr(pdf.state, 'anonymized', False):
+                if pdf.state and getattr(pdf.state, "anonymized", False):
                     logger.info(f"RawPdfFile {file_id} already processed, skipping")
                     return "pdf"
-                
-                # Get file path
-                if not pdf.file or not hasattr(pdf.file, 'path'):
+
+                file_field = pdf.file
+                if not file_field or not file_field.name:
                     logger.error(f"PDF file not found for RawPdfFile {file_id}")
                     return None
-                
-                file_path = Path(pdf.file.path)
-                if not file_path.exists():
-                    logger.error(f"PDF file does not exist: {file_path}")
+
+                if not file_exists(file_field):
+                    logger.error("PDF file missing from storage for RawPdfFile %s", file_id)
                     return None
-                
+
                 # Get center name
                 center_name = pdf.center.name if pdf.center else "unknown_center"
-                
+
                 # Mark as started
                 if pdf.state:
                     pdf.state.processing_started = True
                     pdf.state.save(update_fields=["processing_started"])
-                elif pdf.sensitive_meta:
+                elif pdf.sensitive_meta and hasattr(pdf.sensitive_meta, "anonymization_started"):
                     pdf.sensitive_meta.anonymization_started = True
                     pdf.sensitive_meta.save(update_fields=["anonymization_started"])
-                
-                
-                # Use PdfImportService for processing
-                # Use PdfImportService for processing
-                self.pdf_service.import_and_anonymize(
-                    file_path=file_path,
-                    center_name=center_name,
-                )
-                
+
+                with ensure_local_file(file_field) as local_path:
+                    self.pdf_service.import_and_anonymize(
+                        file_path=local_path,
+                        center_name=center_name,
+                    )
+
                 logger.info(f"PDF processing completed for RawPdfFile ID: {file_id}")
                 return "pdf"
-                
+
             except Exception as e:
                 logger.error(f"Failed to process RawPdfFile {file_id}: {e}")
                 # Mark as failed if state exists
-                if pdf.state:
+                if pdf.state and hasattr(pdf.state, "processing_failed"):
                     pdf.state.processing_failed = True
                     pdf.state.save(update_fields=["processing_failed"])
-                elif pdf.sensitive_meta:
+                elif pdf.sensitive_meta and hasattr(pdf.sensitive_meta, "processing_failed"):
                     pdf.sensitive_meta.processing_failed = True
                     pdf.sensitive_meta.save(update_fields=["processing_failed"])
                 raise
@@ -183,41 +179,47 @@ class AnonymizationService:
     def validate(file_id: int):
         vf = VideoFile.objects.select_related("state").filter(pk=file_id).first()
         if vf:
-            vf.state.mark_anonymization_validated()
+            state = vf.state or vf.get_or_create_state()
+            if hasattr(state, "mark_anonymization_validated"):
+                state.mark_anonymization_validated()
             return "video"
 
         pdf = RawPdfFile.objects.select_related("state").filter(pk=file_id).first()
         if pdf:
-            pdf.state.mark_anonymization_validated()
+            state = pdf.state or pdf.get_or_create_state()
+            if hasattr(state, "mark_anonymization_validated"):
+                state.mark_anonymization_validated()
             return "pdf"
 
         return None
-    
+
+    @staticmethod
     def list_items():
         video_files = VideoFile.objects.select_related("state").all()
         pdf_files = RawPdfFile.objects.select_related("state").all()  # was sensitive_meta
 
         data = []
         for vf in video_files:
-            data.append({
-                "id": vf.id,
-                "mediaType": "video",
-                "anonymizationStatus": vf.state.anonymization_status if vf.state else "not_started",
-                "createdAt": vf.date_created,
-                "updatedAt": vf.date_modified,
-            })
-            
-            
+            data.append(
+                {
+                    "id": vf.pk,
+                    "mediaType": "video",
+                    "anonymizationStatus": vf.state.anonymization_status if vf.state else "not_started",
+                    "createdAt": vf.date_created,
+                    "updatedAt": vf.date_modified,
+                }
+            )
 
         for pdf in pdf_files:
-            data.append({
-                "id": pdf.id,
-                "mediaType": "pdf",
-                "anonymizationStatus": pdf.state.anonymization_status if pdf.state else "not_started",
-                "createdAt": pdf.date_created,
-                "updatedAt": pdf.date_modified,
-            })
+            data.append(
+                {
+                    "id": pdf.pk,
+                    "mediaType": "pdf",
+                    "anonymizationStatus": pdf.state.anonymization_status if pdf.state else "not_started",
+                    "createdAt": pdf.date_created,
+                    "updatedAt": pdf.date_modified,
+                }
+            )
         return data
 
-
         return data