endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/serializers/meta/sensitive_meta_update.py

@@ -0,0 +1,153 @@
+from rest_framework import serializers
+from django.db import transaction
+import logging
+
+from ...models import SensitiveMeta, Center, Gender
+
+logger = logging.getLogger(__name__)
+
+
+class SensitiveMetaUpdateSerializer(serializers.ModelSerializer):
+    """
+    Serializer for updating SensitiveMeta fields including verification state.
+    Handles partial updates and state management.
+    """
+
+    # Verification state fields
+    dob_verified = serializers.BooleanField(required=False)
+    names_verified = serializers.BooleanField(required=False)
+
+    # Center can be updated by name
+    center_name = serializers.CharField(write_only=True, required=False)
+
+    # Gender can be updated by name
+    patient_gender_name = serializers.CharField(write_only=True, required=False)
+
+    class Meta:
+        model = SensitiveMeta
+        fields = [
+            "patient_first_name",
+            "patient_last_name",
+            "patient_dob",
+            "examination_date",
+            "center_name",
+            "patient_gender_name",
+            "endoscope_type",
+            "endoscope_sn",
+            "examiner_first_name",
+            "examiner_last_name",
+            "dob_verified",
+            "names_verified",
+        ]
+
+    def validate_center_name(self, value):
+        """
+        Validates that a center with the given natural key exists.
+
+        Raises a validation error if the specified center does not exist.
+        """
+        if value:
+            try:
+                Center.objects.get_by_natural_key(value)
+                return value
+            except Center.DoesNotExist:
+                raise serializers.ValidationError(f"Center '{value}' does not exist.")
+        return value
+
+    def validate_patient_gender_name(self, value):
+        """
+        Validates that a gender with the given name exists.
+
+        Raises a validation error if no matching Gender is found.
+        """
+        if value:
+            try:
+                Gender.objects.get(name=value)
+                return value
+            except Gender.DoesNotExist:
+                raise serializers.ValidationError(f"Gender '{value}' does not exist.")
+        return value
+
+    def validate(self, data):
+        """
+        Validate that patient first and last names, if provided, are not empty strings.
+
+        Raises a validation error if either `patient_first_name` or `patient_last_name` is present but empty.
+        """
+        # Ensure names are not empty if provided
+        first_name = data.get("patient_first_name")
+        if first_name is not None and not first_name.strip():
+            raise serializers.ValidationError(
+                {"patient_first_name": "First name cannot be empty."}
+            )
+
+        last_name = data.get("patient_last_name")
+        if last_name is not None and not last_name.strip():
+            raise serializers.ValidationError(
+                {"patient_last_name": "Last name cannot be empty."}
+            )
+
+        return data
+
+    @transaction.atomic
+    def update(self, instance, validated_data):
+        """
+        Updates a SensitiveMeta instance with provided data, including related center, gender, and verification state fields.
+
+        Handles assignment of related Center and Gender objects by name, updates model fields, and manages verification state flags (`dob_verified`, `names_verified`) in the associated state object if provided.
+
+        Returns:
+            SensitiveMeta: The updated SensitiveMeta instance.
+        """
+        # Extract verification state data
+        dob_verified = validated_data.pop("dob_verified", None)
+        names_verified = validated_data.pop("names_verified", None)
+
+        # Extract and handle center update
+        center_name = validated_data.pop("center_name", None)
+        if center_name:
+            try:
+                center = Center.objects.get_by_natural_key(center_name)
+                instance.center = center
+            except Center.DoesNotExist:
+                logger.error(f"Center '{center_name}' not found during update")
+                raise serializers.ValidationError(
+                    f"Center '{center_name}' does not exist."
+                )
+
+        # Extract and handle gender update
+        patient_gender_name = validated_data.pop("patient_gender_name", None)
+        if patient_gender_name:
+            try:
+                gender = Gender.objects.get(name=patient_gender_name)
+                instance.patient_gender = gender
+            except Gender.DoesNotExist:
+                logger.error(f"Gender '{patient_gender_name}' not found during update")
+                raise serializers.ValidationError(
+                    f"Gender '{patient_gender_name}' does not exist."
+                )
+
+        # Update regular fields using the model's update_from_dict method
+        if validated_data:
+            instance.update_from_dict(validated_data)
+
+        # Update verification state if provided
+        if dob_verified is not None or names_verified is not None:
+            # Ensure state exists
+            state = instance.get_or_create_state()
+
+            if dob_verified is not None:
+                state.dob_verified = dob_verified
+                logger.info(
+                    f"Updated DOB verification for SensitiveMeta {instance.pk}: {dob_verified}"
+                )
+
+            if names_verified is not None:
+                state.names_verified = names_verified
+                logger.info(
+                    f"Updated names verification for SensitiveMeta {instance.pk}: {names_verified}"
+                )
+
+            state.save()
+
+        return instance

endoreg_db/serializers/meta/sensitive_meta_verification.py

@@ -0,0 +1,62 @@
+from rest_framework import serializers
+import logging
+
+from ...models import SensitiveMeta
+
+logger = logging.getLogger(__name__)
+
+
+class SensitiveMetaVerificationSerializer(serializers.Serializer):
+    """
+    Simple serializer for bulk verification state updates.
+    Used when only updating verification flags.
+    """
+
+    sensitive_meta_id = serializers.IntegerField()
+    dob_verified = serializers.BooleanField(required=False)
+    names_verified = serializers.BooleanField(required=False)
+
+    def validate_sensitive_meta_id(self, value):
+        """
+        Validates that a SensitiveMeta object with the given ID exists and caches it.
+
+        Raises:
+            ValidationError: If no SensitiveMeta object is found with the specified ID.
+        """
+        try:
+            # Retrieve and cache the SensitiveMeta instance to avoid a second query in the save method.
+            self._cached_sensitive_meta = SensitiveMeta.objects.get(id=value)
+            return value
+        except SensitiveMeta.DoesNotExist:
+            raise serializers.ValidationError(
+                f"SensitiveMeta with ID {value} does not exist."
+            )
+
+    def save(self):
+        """
+        Updates the verification state for a specified SensitiveMeta instance.
+
+        Uses the cached SensitiveMeta object from validation, obtains or creates its verification state,
+        updates the `dob_verified` and `names_verified` fields if provided, and saves the changes.
+
+        Returns:
+            The updated verification state object.
+        """
+        sensitive_meta_id = self.validated_data["sensitive_meta_id"]
+        dob_verified = self.validated_data.get("dob_verified")
+        names_verified = self.validated_data.get("names_verified")
+
+        # Use the cached instance from the validation step, avoiding a redundant query.
+        sensitive_meta = self._cached_sensitive_meta
+        state = sensitive_meta.get_or_create_state()
+
+        if dob_verified is not None:
+            state.dob_verified = dob_verified
+
+        if names_verified is not None:
+            state.names_verified = names_verified
+
+        state.save()
+
+        logger.info(f"Updated verification state for SensitiveMeta {sensitive_meta_id}")
+        return state

endoreg_db/serializers/meta/video_meta.py

@@ -0,0 +1,39 @@
+from pathlib import Path
+from rest_framework import serializers
+from endoreg_db.models import VideoMeta, VideoImportMeta
+
+
+class VideoMetaSerializer(serializers.ModelSerializer):
+    fps = serializers.FloatField(read_only=True, allow_null=True)
+    duration = serializers.FloatField(read_only=True, allow_null=True)
+    width = serializers.IntegerField(read_only=True, allow_null=True)
+    height = serializers.IntegerField(read_only=True, allow_null=True)
+    frame_count = serializers.IntegerField(read_only=True, allow_null=True)
+    created_at = serializers.SerializerMethodField()
+
+    def get_created_at(self, obj):
+        # returns created_at if your model has it, else None
+        return getattr(obj, "created_at", None)
+
+    class Meta:
+        model = VideoMeta
+        fields = (
+            "id",
+            "fps",
+            "duration",
+            "width",
+            "height",
+            "frame_count",
+            "created_at",
+        )
+
+
+class VideoImportMetaSerializer(serializers.ModelSerializer):
+    file_name = serializers.SerializerMethodField()
+
+    def get_file_name(self, obj):
+        return Path(obj.file_name).name if obj.file_name else None
+
+    class Meta:
+        model = VideoImportMeta
+        fields = ("id", "file_name", "video_anonymized")

endoreg_db/serializers/misc/__init__.py

@@ -0,0 +1,14 @@
+from .file_overview import FileOverviewSerializer
+from .sensitive_patient_data import VoPPatientDataSerializer
+from .stats import StatsSerializer
+from .upload_job import UploadJobStatusSerializer, UploadCreateResponseSerializer
+from .translatable_field_mix_in import TranslatableFieldMixin
+
+__all__ = [
+    "FileOverviewSerializer",
+    "VoPPatientDataSerializer",
+    "StatsSerializer",
+    "UploadJobStatusSerializer",
+    "UploadCreateResponseSerializer",
+    "TranslatableFieldMixin",
+]

endoreg_db/serializers/misc/file_overview.py

@@ -0,0 +1,72 @@
+from typing import TYPE_CHECKING
+
+from rest_framework import serializers
+
+from endoreg_db.models.media import RawPdfFile, VideoFile
+from endoreg_db.models.state.anonymization import AnonymizationState
+
+if TYPE_CHECKING:
+    pass
+
+class FileOverviewSerializer(serializers.Serializer):
+    id = serializers.IntegerField(read_only=True)
+    filename = serializers.CharField(read_only=True)
+    mediaType = serializers.CharField(read_only=True)
+    anonymizationStatus = serializers.CharField(read_only=True)
+    annotationStatus = serializers.CharField(read_only=True)
+    createdAt = serializers.DateTimeField(read_only=True)
+    sensitiveMetaId = serializers.IntegerField(read_only=True, allow_null=True)
+    fileSize = serializers.IntegerField(read_only=True, required=False)
+    
+    def to_representation(self, instance):
+        # 1. Extract Type-Specific Data
+        if isinstance(instance, VideoFile):
+            media_type = "video"
+            filename = instance.original_file_name or (
+                instance.raw_file.name.split("/")[-1] if instance.raw_file else "unknown_video"
+            )
+            created_at = instance.uploaded_at
+            # Use the state relation optimized in the View
+            state_obj = instance.state
+            sensitive_meta = instance.sensitive_meta
+            try:
+                file_size = instance.raw_file.size if instance.raw_file else 0
+            except:
+                file_size = 0
+
+        elif isinstance(instance, RawPdfFile):
+            media_type = "pdf"
+            filename = instance.file.name.split("/")[-1] if instance.file else "unknown_report"
+            created_at = instance.date_created
+            state_obj = instance.state
+            sensitive_meta = instance.sensitive_meta
+            try:
+                file_size = instance.file.size if instance.file else 0
+            except:
+                file_size = 0
+
+        else:
+            raise TypeError(f"Unexpected object type: {type(instance)}")
+
+        # 2. Determine Status (Single Source of Truth: The State Model)
+        # This uses the @property .anonymization_status from VideoState/RawPdfState
+        raw_status = state_obj.anonymization_status if state_obj else AnonymizationState.NOT_STARTED
+
+        # 3. Map to Frontend 'annotationStatus'
+        annot_status = "not_started"
+        
+        # FIX: Explicitly check against the Enum value
+        if raw_status == AnonymizationState.VALIDATED:
+            annot_status = "validated"
+        
+        # 4. Return Payload
+        return {
+            "id": instance.pk,
+            "filename": filename,
+            "mediaType": media_type,
+            "anonymizationStatus": raw_status,
+            "annotationStatus": annot_status,
+            "createdAt": created_at,
+            "sensitiveMetaId": sensitive_meta.pk if sensitive_meta else None,
+            "fileSize": file_size,
+        }

endoreg_db/serializers/misc/sensitive_patient_data.py

@@ -0,0 +1,144 @@
+from rest_framework import serializers
+
+from endoreg_db.models.media import RawPdfFile, VideoFile
+
+# TODO add this "naming convention" to the documentation
+# VoP: Video or Pdf
+
+
+class VoPPatientDataSerializer(serializers.Serializer):
+    """
+    Serializer that converts a VideoFile or RawPdfFile to the structure
+    the Pinia store needs for validation workflow.
+    """
+
+    # Mark all fields as read_only since they're computed in to_representation
+    id = serializers.IntegerField(read_only=True)
+    sensitiveMetaId = serializers.IntegerField(read_only=True)
+    text = serializers.CharField(read_only=True)
+    anonymizedText = serializers.CharField(read_only=True)
+    reportMeta = serializers.JSONField(read_only=True)
+    status = serializers.CharField(read_only=True)
+    error = serializers.BooleanField(read_only=True)
+
+    def to_representation(self, instance):
+        """
+        Serialize a VideoFile or RawPdfFile instance into a structured dictionary for validation workflows.
+
+        Depending on the instance type, constructs a dictionary containing identifiers, sensitive metadata, text summaries, anonymized text, processing status, and error flag. For VideoFile instances, generates a text summary from associated sensitive metadata and anonymizes personal identifiers. For RawPdfFile instances, uses the instance's text fields directly. Raises a TypeError if the instance is neither type.
+
+        Parameters:
+            instance: A VideoFile or RawPdfFile model instance to serialize.
+
+        Returns:
+            dict: A structured representation of the instance suitable for Pinia store consumption.
+        """
+        if isinstance(instance, VideoFile):
+            # For videos, we don't have text content in the traditional sense
+            # But we can extract metadata text from sensitive_meta
+            text = ""
+            anonym_text = ""
+
+            if instance.sensitive_meta:
+                sm = instance.sensitive_meta
+                # Create a structured text representation similar to FileOverviewSerializer
+                text_parts = []
+
+                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.examination_date:
+                    text_parts.append(f"Examination Date: {sm.examination_date}")
+
+                if sm.center:
+                    text_parts.append(f"Center: {sm.center.name}")
+
+                text = "\n".join(text_parts)
+
+                # Create anonymized version
+                anonym_text = text
+                if sm.patient_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]"
+                    )
+                if sm.patient_dob:
+                    anonym_text = anonym_text.replace(
+                        str(sm.patient_dob.date()), "[DOB]"
+                    )
+
+            return {
+                "id": instance.pk,
+                "sensitiveMetaId": instance.sensitive_meta.pk
+                if instance.sensitive_meta
+                else None,
+                "text": text,
+                "anonymizedText": anonym_text,
+                "reportMeta": self._serialize_sensitive_meta(instance.sensitive_meta)
+                if instance.sensitive_meta
+                else None,
+                "status": "processing"
+                if instance.state and instance.state.frames_extracted
+                else "not_started",
+                "error": False,
+            }
+
+        elif isinstance(instance, RawPdfFile):
+            # Generate report streaming URL using pdf_id (RawPdfFile.id)
+            report_stream_url = f"/api/media/pdfs/{instance.pk}/stream/"
+
+            return {
+                "id": instance.pk,
+                "sensitiveMetaId": instance.sensitive_meta.pk
+                if instance.sensitive_meta
+                else None,
+                "text": instance.text or "",
+                "anonymizedText": instance.anonymized_text or "",
+                "reportMeta": self._serialize_sensitive_meta(instance.sensitive_meta)
+                if instance.sensitive_meta
+                else None,
+                "status": "done" if instance.anonymized_text else "not_started",
+                "error": False,
+                "pdfStreamUrl": report_stream_url,
+            }
+
+        else:
+            raise TypeError(
+                f"Unsupported instance for VoPPatientDataSerializer: {type(instance)}"
+            )
+
+    def _serialize_sensitive_meta(self, sensitive_meta):
+        """
+        Serialize a SensitiveMeta object into a dictionary with patient and examination details.
+
+        Returns:
+            dict or None: A dictionary containing patient and examination metadata fields, or None if sensitive_meta is not provided.
+        """
+        if not sensitive_meta:
+            return None
+
+        return {
+            "id": sensitive_meta.pk,
+            "patientFirstName": sensitive_meta.patient_first_name or "",
+            "patientLastName": sensitive_meta.patient_last_name or "",
+            "patientDob": sensitive_meta.patient_dob.isoformat()
+            if sensitive_meta.patient_dob
+            else "",
+            "patientGender": str(sensitive_meta.patient_gender)
+            if sensitive_meta.patient_gender
+            else "",
+            "examinationDate": sensitive_meta.examination_date.isoformat()
+            if sensitive_meta.examination_date
+            else "",
+            "centerName": sensitive_meta.center.name if sensitive_meta.center else "",
+            "endoscopeType": sensitive_meta.endoscope_type or "",
+            "endoscopeSn": sensitive_meta.endoscope_sn or "",
+            "isVerified": getattr(sensitive_meta, "is_verified", False),
+        }

endoreg_db/serializers/misc/stats.py

@@ -0,0 +1,35 @@
+from rest_framework import serializers
+
+
+class StatsSerializer(serializers.Serializer):
+    """
+    Serializer for statistics data from AuditLedger.
+
+    This serializer defines the structure of statistics data and ensures
+    consistent API responses.
+    """
+
+    totalCases = serializers.IntegerField()
+    totalVideos = serializers.IntegerField()
+    totalAnnotations = serializers.IntegerField()
+    totalAnonymizations = serializers.IntegerField()
+    totalImages = serializers.IntegerField()
+    videosCompleted = serializers.IntegerField()
+    videosAnonym = serializers.IntegerField()
+
+    # You can add additional fields or methods here as needed
+    # For example, to calculate derived statistics:
+    # TODO
+    def get_completion_percentage(self, obj):
+        """
+        Calculates the percentage of completed videos out of the total videos.
+
+        Args:
+            obj: A dictionary containing 'videosCompleted' and 'totalVideos' keys.
+
+        Returns:
+            The completion percentage as a float rounded to two decimal places, or 0 if totalVideos is zero or less.
+        """
+        if obj["totalVideos"] > 0:
+            return round((obj["videosCompleted"] / obj["totalVideos"]) * 100, 2)
+        return 0

endoreg_db/serializers/misc/translatable_field_mix_in.py

@@ -0,0 +1,44 @@
+from django.utils.translation import get_language
+
+
+class TranslatableFieldMixin:
+    """Mixin für automatische Sprachauswahl basierend auf Accept-Language"""
+
+    def get_localized_name(self, obj, field_base="name"):
+        """
+        Retrieve a localized value for a specified field from an object, using language preference fallbacks.
+
+        Attempts to return the value of the field with the current language code suffix (e.g., `name_en`). If unavailable or empty, falls back to the German (`_de`) version, then the English (`_en`) version, and finally the base field without a language suffix. Returns an empty string if no value is found.
+
+        Parameters:
+            obj: The object containing the translatable fields.
+            field_base (str): The base name of the field to localize (default is 'name').
+
+        Returns:
+            str: The localized field value, or an empty string if none is available.
+        """
+        current_lang = get_language() or "en"
+
+        # Versuche sprachspezifisches Feld
+        lang_field = f"{field_base}_{current_lang}"
+        if hasattr(obj, lang_field):
+            value = getattr(obj, lang_field)
+            if value:
+                return value
+
+        # Fallback auf Deutsch
+        de_field = f"{field_base}_de"
+        if hasattr(obj, de_field):
+            value = getattr(obj, de_field)
+            if value:
+                return value
+
+        # Fallback auf Englisch
+        en_field = f"{field_base}_en"
+        if hasattr(obj, en_field):
+            value = getattr(obj, en_field)
+            if value:
+                return value
+
+        # Letzter Fallback auf Basis-Feld
+        return getattr(obj, field_base, "")

endoreg_db/serializers/misc/upload_job.py

@@ -0,0 +1,74 @@
+from rest_framework import serializers
+from endoreg_db.models.upload_job import UploadJob
+
+
+class UploadJobStatusSerializer(serializers.ModelSerializer):
+    """
+    Read-only serializer for upload job status responses.
+    Returns status information for polling endpoints.
+    """
+
+    sensitive_meta_id = serializers.IntegerField(
+        source="sensitive_meta.id",
+        read_only=True,
+        allow_null=True,
+        help_text="ID of the created SensitiveMeta record (only when anonymized)",
+    )
+
+    # Optional helper fields for preview (can be populated by view if needed)
+    text = serializers.CharField(read_only=True, required=False, allow_blank=True)
+    anonymized_text = serializers.CharField(
+        read_only=True, required=False, allow_blank=True
+    )
+
+    class Meta:
+        model = UploadJob
+        fields = [
+            "status",
+            "error_detail",
+            "sensitive_meta_id",
+            "id",
+            "text",
+            "anonymized_text",
+        ]
+        read_only_fields = fields
+
+    def to_representation(self, instance):
+        """
+        Customize the representation to only include relevant fields based on status.
+        """
+        data = super().to_representation(instance)
+
+        # Only include error_detail if status is error
+        if instance.status != UploadJob.Status.ERROR:
+            data.pop("error_detail", None)
+
+        # Only include sensitive_meta_id if status is anonymized and we have a meta record
+        if (
+            instance.status != UploadJob.Status.ANONYMIZED
+            or not instance.sensitive_meta
+        ):
+            data.pop("sensitive_meta_id", None)
+
+        # Remove empty optional fields
+        if not data.get("text"):
+            data.pop("text", None)
+        if not data.get("anonymized_text"):
+            data.pop("anonymized_text", None)
+
+        return data
+
+
+class UploadCreateResponseSerializer(serializers.Serializer):
+    """
+    Serializer for the initial upload response.
+    Returns upload_id and status_url for polling.
+    """
+
+    upload_id = serializers.UUIDField(
+        read_only=True, help_text="UUID of the created upload job"
+    )
+
+    status_url = serializers.CharField(
+        read_only=True, help_text="URL to poll for upload status updates"
+    )

endoreg_db/serializers/patient/__init__.py

@@ -0,0 +1,12 @@
+from .patient import (
+    PatientSerializer,
+)
+
+from .patient_dropdown import (
+    PatientDropdownSerializer,
+)
+
+__all__ = [
+    "PatientSerializer",
+    "PatientDropdownSerializer",
+]