endoreg-db 0.8.9.32__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/__init__.py

@@ -0,0 +1,5 @@
+"""
+Services package for endoreg_db.
+
+Contains business logic services that can be reused across different parts of the application.
+"""

endoreg_db/services/anonymization.py

@@ -0,0 +1,274 @@
+# endoreg_db/services/anonymization.py
+import logging
+from pathlib import Path
+from typing import Optional, Literal
+
+from django.db import transaction
+
+from endoreg_db.models import RawPdfFile, VideoFile
+from endoreg_db.services.video_import import VideoImportService
+from endoreg_db.services.report_import import ReportImportService
+from endoreg_db.utils.paths import STORAGE_DIR
+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: Optional[Path] = None):
+        """
+        Initialize the AnonymizationService with service instances.
+
+        Args:
+            project_root: Path to the project root. If None, uses settings.BASE_DIR
+        """
+        self.project_root: Path = project_root or STORAGE_DIR
+        self.video_service = VideoImportService()
+        self.pdf_service = ReportImportService()
+
+    @staticmethod
+    def get_status(file_id: int, kind: Optional[str] = None) -> Optional[dict]:
+        """
+        Retrieve status. 
+        Handles 'pdf' vs 'report' alias.
+        If kind is None, checks both tables (Video priority).
+        """
+        
+        # 1. Normalize the input kind if legacy name pdf is used
+        if kind == 'pdf':
+            kind = 'report'
+            
+        # 2. Define lookup logic
+        check_video = kind == "video" or kind is None
+        check_report = kind == "report" or kind is None
+
+        # 3. Check VideoFile
+        if check_video:
+            vf = (
+                VideoFile.objects.select_related("state", "sensitive_meta")
+                .filter(pk=file_id)
+                .first()
+            )
+            if vf:
+                return {
+                    "mediaType": "video",
+                    "anonymizationStatus": vf.state.anonymization_status
+                    if vf.state
+                    else "not_started",
+                    "fileExists": file_exists(vf.raw_file),
+                    "uuid": str(vf.video_hash) if vf.video_hash else None,
+                }
+
+        # 4. Check RawPdfFile
+        if check_report:
+            pdf = (
+                RawPdfFile.objects.select_related("state", "sensitive_meta")
+                .filter(pk=file_id)
+                .first()
+            )
+            if pdf:
+                return {
+                    "mediaType": "pdf",
+                    "anonymizationStatus": pdf.state.anonymization_status
+                    if pdf.state
+                    else "not_started",
+                    "fileExists": file_exists(pdf.file),
+                    "hash": pdf.pdf_hash,
+                }
+                
+        # 5. Not found in either (or the specific requested type wasn't found)
+        return None
+
+    # ---------- COMMANDS ------------------------------------------------
+    @transaction.atomic
+    def start(self, file_id: int, kind: Optional[str] = None) -> Optional[str]:
+        """
+        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
+        """
+        # Try VideoFile first
+        if kind == "video" or kind is None:
+            vf = (
+                VideoFile.objects.select_related(
+                    "state", "sensitive_meta", "center", "video_meta__processor"
+                )
+                .filter(pk=file_id)
+                .first()
+            )
+            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:
+                        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=safe_processor_name,
+                    )
+
+                    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
+                    if vf.state:
+                        vf.state.processing_started = (
+                            False  # Mark processing as not started due to failure
+                        )
+                        vf.state.save(update_fields=["processing_started"])
+                    raise
+        elif kind == "report" or kind is None:
+            # Try RawPdfFile
+            pdf = (
+                RawPdfFile.objects.select_related("state", "sensitive_meta", "center")
+                .filter(pk=file_id)
+                .first()
+            )
+            if pdf:
+                try:
+                    logger.info(f"Starting report processing for RawPdfFile ID: {file_id}")
+
+                    # Check if already processed
+                    if pdf.state and getattr(pdf.state, "anonymized", False):
+                        logger.info(f"RawPdfFile {file_id} already processed, skipping")
+                        return "pdf"
+
+                    file_field = pdf.file
+                    if not file_field or not file_field.name:
+                        logger.error(f"report file not found for RawPdfFile {file_id}")
+                        return None
+
+                    if not file_exists(file_field):
+                        logger.error(
+                            "report 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"])
+
+                    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"report 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 and hasattr(pdf.state, "processing_failed"):
+                        pdf.state.save(update_fields=["processing_failed"])
+                    elif pdf.sensitive_meta and hasattr(
+                        pdf.sensitive_meta, "processing_failed"
+                    ):
+                        pdf.sensitive_meta.save(update_fields=["processing_failed"])
+                    raise
+
+            logger.warning(f"No file found with ID: {file_id}")
+            return None
+
+    @staticmethod
+    @transaction.atomic
+    def validate(file_id: int) -> None | Literal['video'] | Literal['pdf']:
+        from endoreg_db.views.anonymization.validate import AnonymizationValidateView
+        
+        vf = VideoFile.objects.select_related("state").filter(pk=file_id).first()
+        if vf:
+            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:
+            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.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.pk,
+                    "mediaType": "pdf",
+                    "anonymizationStatus": pdf.state.anonymization_status
+                    if pdf.state
+                    else "not_started",
+                    "createdAt": pdf.date_created,
+                    "updatedAt": pdf.date_modified,
+                }
+            )
+        return data

endoreg_db/services/examination_evaluation.py

@@ -0,0 +1,172 @@
+# app/services/evaluation.py
+from __future__ import annotations
+from typing import List, Set, Tuple
+
+from endoreg_db.schemas.examination_evaluation import (
+    ExaminationEvalReport,
+    RequirementSetEval,
+    RequirementEval,
+)
+from endoreg_db.models.medical.patient.patient_examination import PatientExamination
+from endoreg_db.models.requirement.requirement_set import RequirementSet
+import endoreg_db.services.lookup_service
+
+
+def _get_requirement_sets_for_exam(exam: PatientExamination) -> List[RequirementSet]:
+    """
+    Decide how an examination maps to requirement sets.
+    Adjust this to your actual relation:
+    - maybe exam.type.requirement_sets
+    - or via information_sources
+    - or a direct M2M on Examination
+    """
+    # The new loader prefetches via `examination.exam_reqset_links`.
+    # We extract the RequirementSet from each link.
+    sets = []
+    if hasattr(exam, "examination") and hasattr(exam.examination, "exam_reqset_links"):
+        for link in exam.examination.exam_reqset_links.all():
+            if hasattr(link, "requirement_set"):
+                sets.append(link.requirement_set)
+    return sets
+
+
+def _eval_requirement(
+    requirement, input_object, mode="loose"
+) -> Tuple[bool, str | None]:
+    """
+    Evaluate a single Requirement and return (bool, message).
+    The `message` can be None or contain a short explanation.
+    """
+    ok = requirement.evaluate(input_object, mode=mode)
+    msg = None
+    # If your Requirement has a reason/explanation API, inject it here.
+    # Example: msg = requirement.last_reason if hasattr(requirement, "last_reason") else None
+    return ok, msg
+
+
+def _reduce_bools(bools: List[bool], set_type_name: str | None) -> bool:
+    from endoreg_db.models.requirement.requirement_set import (
+        REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP,
+    )
+
+    func = REQUIREMENT_SET_TYPE_FUNCTION_LOOKUP.get(set_type_name or "all", all)
+    return bool(func(bools))
+
+
+def _eval_set_tree(
+    root: RequirementSet, input_object, visited: Set[int]
+) -> RequirementSetEval:
+    """
+    Recursively evaluate a RequirementSet node and linked children.
+    Protect against cycles with visited set.
+    """
+    if root.pk in visited:
+        # Cycle detected -> treat as already evaluated (neutral element for AND is True; but better: skip node)
+        # We skip to avoid infinite recursion; AND/OR exact treatment depends on your business semantics.
+        return RequirementSetEval(
+            id=root.pk,
+            name=root.name,
+            type=(
+                root.requirement_set_type.name if root.requirement_set_type else None
+            ),
+            is_satisfied=True,
+            requirements=[],
+            linked_sets=[],
+        )
+
+    visited.add(root.pk)
+
+    # Evaluate direct requirements
+    req_evals: List[RequirementEval] = []
+    for r in root.requirements.all():
+        ok, msg = _eval_requirement(r, input_object)
+        req_evals.append(
+            RequirementEval(
+                id=r.pk,
+                name=getattr(r, "name", f"Requirement {r.pk}"),
+                description=getattr(r, "description", None),
+                satisfied=ok,
+                message=msg,
+            )
+        )
+
+    # Evaluate linked sets
+    child_evals: List[RequirementSetEval] = []
+    for child in root.links_to_sets.all():
+        child_evals.append(_eval_set_tree(child, input_object, visited))
+
+    # Combine booleans
+    bools = [re.satisfied for re in req_evals] + [ce.is_satisfied for ce in child_evals]
+    set_type_name = (
+        root.requirement_set_type.name if root.requirement_set_type else "all"
+    )
+    satisfied = _reduce_bools(bools, set_type_name)
+
+    return RequirementSetEval(
+        id=root.pk,
+        name=root.name,
+        type=set_type_name,
+        is_satisfied=satisfied,
+        requirements=req_evals,
+        linked_sets=child_evals,
+    )
+
+
+def evaluate_examination(request: dict) -> ExaminationEvalReport:
+    """
+    Communicates with: components/RequirementGenerator
+    Evaluates a PatientExamination by its Lookup. The frontend sends this structure:
+
+
+        requirement_set_ids: plainRequirementSetIds,
+        lookup_token: lookupToken,
+        patient_examination_id: patientExaminationId
+    };
+
+    And expects a response to be processed like this:
+
+            const response = await axiosInstance.post('/api/evaluate-requirements/', payload);
+            const results = response.data.results || [];
+            const summary = response.data.summary || {};
+
+            // Update evaluation results
+            plainRequirementSetIds.forEach((setId: number) => {
+                evaluationResults.value[setId] = results.filter((r: RequirementEvaluationResult) =>
+                    summary[setId]?.requirements.includes(r.requirement_name)
+                );
+            });
+    """
+    exam_id = request.get("patient_examination_id")
+    if not exam_id:
+        return ExaminationEvalReport(
+            examination_id=None,
+            summary={"is_satisfied": True, "failed_count": 0, "total_sets": 0},
+            sets=[],
+            errors=["No patient_examination_id provided in request."],
+        )
+
+    # Use the dedicated loader function from the lookup service.
+    exam = endoreg_db.services.lookup_service.load_patient_exam_for_eval(pk=exam_id)
+
+    # This object (exam) is the "input_object" for requirement.evaluate(...)
+    sets = _get_requirement_sets_for_exam(exam)
+
+    visited: Set[int] = set()
+    set_evals: List[RequirementSetEval] = [
+        _eval_set_tree(s, exam, visited) for s in sets
+    ]
+
+    # Aggregate summary
+    overall = all(se.is_satisfied for se in set_evals) if set_evals else True
+    failed = sum(1 for se in set_evals if not se.is_satisfied)
+
+    return ExaminationEvalReport(
+        examination_id=exam.pk,
+        summary={
+            "is_satisfied": overall,
+            "failed_count": failed,
+            "total_sets": len(set_evals),
+        },
+        sets=set_evals,
+        errors=[],  # fill with any global issues you detect
+    )