endoreg-db 0.8.6.4__py3-none-any.whl

endoreg_db/serializers/anonymization.py

@@ -0,0 +1,69 @@
+"""
+Serializers für Anonymisierungs-Validierung mit deutschem Datumsformat.
+
+Unterstützt DD.MM.YYYY als Primärformat und YYYY-MM-DD als Fallback.
+"""
+
+from rest_framework import serializers
+from endoreg_db.models.metadata.sensitive_meta_logic import parse_any_date
+
+
+class SensitiveMetaValidateSerializer(serializers.Serializer):
+    """
+    Serializer für SensitiveMeta-Validierung mit deutscher Datums-Priorität.
+    
+    Akzeptiert Datumsfelder in folgenden Formaten:
+    1. DD.MM.YYYY (bevorzugt) - deutsches Format
+    2. YYYY-MM-DD (Fallback) - ISO-Format
+    
+    Alle Datumsfelder werden in date-Objekte konvertiert.
+    """
+    
+    patient_first_name = serializers.CharField(required=False, allow_blank=True)
+    patient_last_name = serializers.CharField(required=False, allow_blank=True)
+    patient_dob = serializers.CharField(required=False, allow_blank=True)
+    examination_date = serializers.CharField(required=False, allow_blank=True)
+    casenumber = serializers.CharField(required=False, allow_blank=True)
+    anonymized_text = serializers.CharField(required=False, allow_blank=True)
+    patient_gender = serializers.CharField(required=False, allow_blank=True)
+    center_name = serializers.CharField(required=False, allow_blank=True)
+    is_verified = serializers.BooleanField(required=False, default=True)
+    file_type = serializers.ChoiceField(
+        choices=['video', 'pdf'], required=False
+    )  # Optional: "video" oder "pdf"
+
+    def validate_patient_dob(self, value):
+        """
+        Validiert patient_dob mit deutscher Format-Priorität.
+        
+        Akzeptierte Formate:
+        - DD.MM.YYYY (z.B. "21.03.1994")
+        - YYYY-MM-DD (z.B. "1994-03-21")
+        """
+        if not value:
+            return None
+            
+        parsed_date = parse_any_date(value)
+        if not parsed_date:
+            raise serializers.ValidationError(
+                "Ungültiges Datum. Erlaubte Formate: DD.MM.YYYY oder YYYY-MM-DD."
+            )
+        return parsed_date
+
+    def validate_examination_date(self, value):
+        """
+        Validiert examination_date mit deutscher Format-Priorität.
+        
+        Akzeptierte Formate:
+        - DD.MM.YYYY (z.B. "15.02.2024")
+        - YYYY-MM-DD (z.B. "2024-02-15")
+        """
+        if not value:
+            return None
+            
+        parsed_date = parse_any_date(value)
+        if not parsed_date:
+            raise serializers.ValidationError(
+                "Ungültiges Datum. Erlaubte Formate: DD.MM.YYYY oder YYYY-MM-DD."
+            )
+        return parsed_date

endoreg_db/serializers/evaluation/examination_evaluation.py

@@ -0,0 +1 @@
+from endoreg_db.models import ExaminationEvaluation

endoreg_db/serializers/examination/__init__.py

@@ -0,0 +1,10 @@
+from .base import ExaminationSerializer, ExaminationTypeSerializer
+from .dropdown import (
+    ExaminationDropdownSerializer,
+)
+
+__all__ = [
+    "ExaminationSerializer",
+    "ExaminationTypeSerializer",
+    "ExaminationDropdownSerializer",
+]

endoreg_db/serializers/examination/base.py

@@ -0,0 +1,46 @@
+# eendoreg_db/serializers/examination/base.py
+from rest_framework import serializers
+from ...models import Examination, ExaminationType
+
+
+class ExaminationTypeSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = ExaminationType
+        fields = ['id', 'name']
+class ExaminationSerializer(serializers.ModelSerializer):
+    
+
+    findings = serializers.SerializerMethodField()
+    examination_types = serializers.SerializerMethodField()
+    class Meta:
+        model = Examination
+        fields = [
+            'id', 'name','findings', 'examination_types'
+        ]
+
+
+    def get_findings(self, obj:Examination):
+        """
+        Return a list of serialized findings associated with the given examination.
+        
+        Parameters:
+            obj (Examination): The examination instance for which to retrieve findings.
+        
+        Returns:
+            list: Serialized data for all findings available to the examination.
+        """
+        from ..finding import FindingSerializer
+        findings = obj.get_available_findings()
+        return FindingSerializer(findings, many=True).data
+
+    def get_examination_types(self, obj:Examination):
+        """
+        Return a list of serialized examination types associated with the given examination.
+        
+        Parameters:
+            obj (Examination): The examination instance for which to retrieve examination types.
+        
+        Returns:
+            list: Serialized data for each related examination type.
+        """
+        return ExaminationTypeSerializer(obj.examination_types.all(), many=True).data

endoreg_db/serializers/examination/dropdown.py

@@ -0,0 +1,21 @@
+from endoreg_db.models import Examination
+
+
+from rest_framework import serializers
+
+
+class ExaminationDropdownSerializer(serializers.ModelSerializer):
+    """Serializer für Examination-Dropdown"""
+    display_name = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Examination
+        fields = ['id', 'name', 'display_name']
+
+    def get_display_name(self, obj):
+            
+            """
+            Return a user-friendly (localized) display name for the examination.
+            Prefers a German translation (`name_de`) when available; otherwise falls back to `name`.   """
+            return getattr(obj, "name_de", None) or obj.name
+

endoreg_db/serializers/examination_serializer.py

@@ -0,0 +1,12 @@
+# endoreg_db/serializers.py
+from rest_framework import serializers
+from ..models import Examination
+
+
+
+class ExaminationSerializer(serializers.ModelSerializer):
+        class Meta:
+            model = Examination
+            fields = ['id', 'name']  # Add other fields as needed
+
+

endoreg_db/serializers/finding/__init__.py

@@ -0,0 +1,5 @@
+from .finding import FindingSerializer
+
+__all__ = [
+    'FindingSerializer',
+]

endoreg_db/serializers/finding/finding.py

@@ -0,0 +1,54 @@
+from rest_framework import serializers
+from ..finding_classification import (
+    FindingClassificationSerializer,
+    # FindingClassificationChoiceSerializer,
+)
+from endoreg_db.models import Finding
+
+class FindingSerializer(serializers.ModelSerializer):
+    
+    location_classifications = serializers.SerializerMethodField()
+    morphology_classifications = serializers.SerializerMethodField()
+    classifications = serializers.SerializerMethodField()
+
+    class Meta:
+        model = Finding
+        fields = [
+            'id', 'name', 'description', "classifications", 'location_classifications', 'morphology_classifications',
+        ]
+
+    def get_location_classifications(self, obj):
+        """
+        Retrieve and serialize all 'location' classifications associated with the given Finding instance.
+        
+        Returns:
+            list: Serialized data for each related classification of type 'location'.
+        """
+        classifications = obj.finding_classifications.filter(
+            classification_types__name__iexact="location"
+        )
+        return FindingClassificationSerializer(classifications, many=True).data
+
+    def get_morphology_classifications(self, obj):
+        """
+        Return serialized morphology classifications associated with the given finding.
+        
+        Parameters:
+            obj: The Finding instance whose morphology classifications are retrieved.
+        
+        Returns:
+            list: Serialized data for all related morphology classifications.
+        """
+        classifications = obj.finding_classifications.filter(
+            classification_types__name__iexact="morphology"
+        )
+        return FindingClassificationSerializer(classifications, many=True).data
+
+    def get_classifications(self, obj):
+        """
+        Retrieve all classifications related to the given finding.
+        
+        Returns:
+            list: Serialized representations of all classifications associated with the finding.
+        """
+        return FindingClassificationSerializer(obj.finding_classifications.all(), many=True).data

endoreg_db/serializers/finding_classification/__init__.py

@@ -0,0 +1,7 @@
+from .choice import FindingClassificationChoiceSerializer
+from .classification import FindingClassificationSerializer
+
+__all__ = [
+    'FindingClassificationChoiceSerializer',
+    'FindingClassificationSerializer',
+]

endoreg_db/serializers/finding_classification/choice.py

@@ -0,0 +1,19 @@
+from endoreg_db.models import FindingClassificationChoice
+from rest_framework import serializers
+
+class FindingClassificationChoiceSerializer(serializers.ModelSerializer):
+    """
+    Serializer for the FindingClassificationChoice model.
+
+    Serializes the following fields:
+        - id: Unique identifier of the classification choice.
+        - name: Name of the classification choice.
+        - description: Description of the classification choice.
+        - subcategories: Related subcategories for further classification.
+        - numerical_descriptors: Associated numerical descriptors for the classification choice.
+    """
+    class Meta:
+        model = FindingClassificationChoice
+        fields = [
+            'id', 'name', 'description', 'subcategories', 'numerical_descriptors'
+        ]

endoreg_db/serializers/finding_classification/classification.py

@@ -0,0 +1,13 @@
+from .choice import FindingClassificationChoiceSerializer
+from endoreg_db.models import FindingClassification
+from rest_framework import serializers
+
+class FindingClassificationSerializer(serializers.ModelSerializer):
+    choices = FindingClassificationChoiceSerializer(many=True, read_only=True)
+
+    class Meta:
+        model = FindingClassification
+        fields = [
+            'id', 'name', 'description', 'choices', 'classification_types'
+        ]
+    

endoreg_db/serializers/label/__init__.py

@@ -0,0 +1,7 @@
+from .label import LabelSerializer
+from .image_classification_annotation import ImageClassificationAnnotationSerializer
+
+__all__ = [
+    'LabelSerializer',
+    'ImageClassificationAnnotationSerializer',
+]

endoreg_db/serializers/label/image_classification_annotation.py

@@ -0,0 +1,62 @@
+from typing import Optional
+from rest_framework import serializers
+
+
+from endoreg_db.models import ImageClassificationAnnotation
+
+
+class ImageClassificationAnnotationSerializer(serializers.ModelSerializer):
+    """
+    Serializer for ImageClassificationAnnotation model.
+    This serializer is used to represent image classification annotations in the API.
+    """
+
+    label_name = serializers.SerializerMethodField()
+    confidence = serializers.SerializerMethodField()
+    frame_number = serializers.IntegerField(source='frame.frame_number', read_only=True)
+
+    class Meta:
+        model = ImageClassificationAnnotation
+        fields = [
+            "id",
+            "label",
+            "confidence",
+            "frame_number",
+            "information_source",
+            "date_created",
+            "date_modified",
+            "label_name",
+        ]
+
+    def get_confidence(self, obj: ImageClassificationAnnotation) -> Optional[float]:
+        """
+        Retrieve the confidence score associated with the annotation.
+        
+        Returns:
+            The float value representing the annotation's confidence, or None if not set.
+        """
+        if obj.float_value is not None:
+            return obj.float_value
+        return None
+
+    def get_label_name(self, obj: ImageClassificationAnnotation) -> str:
+        """
+        Returns the name of the label associated with the annotation, or "No Label" if no label is set.
+        """
+        return obj.label.name if obj.label else "No Label"
+
+    def to_representation(self, instance: ImageClassificationAnnotation) -> dict:
+        """
+        Return the serialized representation of an ImageClassificationAnnotation instance.
+        
+        Overrides the default method to allow for future customization of the serialized output, but currently returns the standard representation unchanged.
+        
+        Parameters:
+            instance (ImageClassificationAnnotation): The annotation instance to serialize.
+        
+        Returns:
+            dict: The serialized data for the annotation.
+        """
+        representation = super().to_representation(instance)
+        # Add any additional fields or transformations here if needed
+        return representation

endoreg_db/serializers/label/label.py

@@ -0,0 +1,15 @@
+from endoreg_db.models import Label
+
+
+from rest_framework import serializers
+
+
+class LabelSerializer(serializers.ModelSerializer):
+    """
+    Serializer for fetching labels from the `endoreg_db_label` table.
+    Includes `id` (for backend processing) and `name` (for dropdown display in Vue.js).
+    """
+
+    class Meta:
+        model = Label
+        fields = ["id", "name"]

endoreg_db/serializers/label_video_segment/__init__.py

@@ -0,0 +1,7 @@
+from .label_video_segment import LabelVideoSegmentSerializer
+from .label_video_segment_annotation import LabelVideoSegmentAnnotationSerializer
+
+__all__ = [
+    "LabelVideoSegmentSerializer",
+    "LabelVideoSegmentAnnotationSerializer"
+]

endoreg_db/serializers/label_video_segment/_lvs_create.py

@@ -0,0 +1,149 @@
+from typing import TYPE_CHECKING
+from django.core.exceptions import ObjectDoesNotExist
+from rest_framework import serializers
+from endoreg_db.models import (
+    Label,
+    VideoFile,
+    LabelVideoSegment,
+    InformationSource
+)
+
+import logging
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from endoreg_db.serializers import LabelVideoSegmentSerializer
+
+def _get_video_file(self, video_id):
+    """
+    Retrieve a VideoFile instance by its ID.
+    
+    Raises a serializers.ValidationError if the VideoFile does not exist.
+    """
+    try:
+        return VideoFile.objects.get(id=video_id)
+    except ObjectDoesNotExist as exc:
+        raise serializers.ValidationError(f"VideoFile with id {video_id} does not exist") from exc
+
+def _get_label(self, label_id, label_name):
+    """
+    Retrieve a Label instance by ID or name, creating it if necessary.
+    
+    Raises a ValidationError if the label cannot be found, created, or if neither identifier is provided.
+    """
+    if label_id:
+        try:
+            return Label.objects.get(id=label_id)
+        except ObjectDoesNotExist as exc:
+            raise serializers.ValidationError(f"Label with id {label_id} does not exist") from exc
+    elif label_name:
+        label, _ = Label.get_or_create_from_name(label_name)
+        if not label:
+            raise serializers.ValidationError(f"Failed to create or retrieve label with name {label_name}")
+        return label
+    else:
+        raise serializers.ValidationError("Either label_id or label_name must be provided")
+
+def _validate_fps(self, video_file):
+    """
+    Validate and return the frames per second (FPS) value from a video file.
+    
+    Raises a validation error if the FPS is missing, not a positive number, or cannot be converted to a float.
+    
+    Returns:
+        float: The validated FPS value.
+    """
+    fps_raw = video_file.get_fps()
+    if fps_raw is None:
+        raise serializers.ValidationError("Video file must have a defined FPS")
+    try:
+        fps = float(fps_raw)
+        if fps <= 0:
+            raise ValueError("FPS must be a positive number")
+    except (ValueError, TypeError):
+        raise serializers.ValidationError("Invalid FPS format in video file")
+    return fps
+
+def _calculate_frame_numbers(self, validated_data, fps):
+    """
+    Convert start and end times in the input data to corresponding frame numbers using the provided FPS value.
+    
+    Parameters:
+        validated_data (dict): Input data containing 'start_time' and 'end_time' keys.
+        fps (float): Frames per second of the video.
+    
+    Returns:
+        dict: The input data dictionary updated with 'start_frame_number' and 'end_frame_number' keys.
+    
+    Raises:
+        serializers.ValidationError: If frame numbers cannot be determined from the provided data.
+    """
+    if validated_data.get('start_time') is not None:
+        validated_data['start_frame_number'] = int(float(validated_data['start_time']) * fps)
+    if validated_data.get('end_time') is not None:
+        validated_data['end_frame_number'] = int(float(validated_data['end_time']) * fps)
+    if 'start_frame_number' not in validated_data or 'end_frame_number' not in validated_data:
+        raise serializers.ValidationError("Could not determine frame numbers from provided data")
+    return validated_data
+
+def _get_information_source(self):
+    """
+    Retrieve or create the information source for manual annotation.
+    
+    Returns:
+        InformationSource: The source object representing manual annotation.
+    """
+    source, _ = InformationSource.objects.get_or_create(
+        name='Manual Annotation',
+        defaults={
+            'description': 'Manually created label segments via web interface',
+        }
+    )
+    return source
+
+def _create(self:"LabelVideoSegmentSerializer", validated_data):
+    """
+    Create and persist a new LabelVideoSegment instance from validated input data.
+    
+    This method extracts relevant fields from the input, retrieves or creates related objects (video file, label, information source), validates video FPS, calculates frame numbers from time values, and creates a new LabelVideoSegment. Raises a validation error if required data is missing or invalid, or if creation fails.
+    
+    Returns:
+        LabelVideoSegment: The newly created and saved segment instance.
+    """
+    try:
+        # Extract convenience fields
+        video_id = validated_data.pop('video_id')
+        label_id = validated_data.pop('label_id', None)
+        label_name = validated_data.pop('label_name', None)
+        start_time = validated_data.pop('start_time', None)
+        end_time = validated_data.pop('end_time', None)
+
+        video_file = self.get_video_file(video_id)
+        label = self.get_label(label_id, label_name)
+        fps = self.validate_fps(video_file)
+        validated_data['start_time'] = start_time
+        validated_data['end_time'] = end_time
+        validated_data = self.calculate_frame_numbers(validated_data, fps)
+        source = self.get_information_source()
+
+        # Create the segment directly
+        segment = LabelVideoSegment.safe_create(
+            video_file=video_file,
+            label=label,
+            source=source,
+            start_frame_number=validated_data['start_frame_number'],
+            end_frame_number=validated_data['end_frame_number'],
+            prediction_meta=None  # No prediction meta for manual annotations
+        )
+        segment.save()
+
+        logger.info("Created new video segment: %s for video %s with label %s",
+                    segment.pk, video_id, label.name if label else 'None')
+        return segment
+
+    except serializers.ValidationError as e:
+        logger.error("Validation error while creating video segment: %s", str(e))
+        raise
+    except Exception as e:
+        logger.error("Unexpected error while creating video segment: %s", str(e))
+        raise serializers.ValidationError(f"Failed to create segment: {str(e)}")

endoreg_db/serializers/label_video_segment/_lvs_update.py

@@ -0,0 +1,138 @@
+from typing import TYPE_CHECKING, Dict, Any, Optional
+from django.core.exceptions import ObjectDoesNotExist
+from rest_framework import serializers
+from endoreg_db.models import (
+    Label,
+    VideoFile,
+    LabelVideoSegment
+)
+
+import logging
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from endoreg_db.serializers import LabelVideoSegmentSerializer
+
+
+def _validate_fps(video: "VideoFile"):
+    """Raises a ValidationError if the video's FPS is invalid."""
+    fps = video.get_fps()
+    if not fps or fps <= 0:
+        raise serializers.ValidationError("The video must have a valid FPS to convert times to frames.")
+    return fps
+
+def _convert_time_to_frame(time_value: float, fps: float) -> int:
+    """Converts a time value in seconds to a frame number."""
+    return int(time_value * fps)
+
+def _update_frames_from_data(instance: "LabelVideoSegment", validated_data: Dict[str, Any], fps: Optional[float]):
+    """Updates start and end frames from either time or frame data."""
+    if 'start_time' in validated_data:
+        if fps is None:
+            fps = _validate_fps(instance.video)
+        instance.start_frame_number = _convert_time_to_frame(validated_data['start_time'], fps)
+    elif 'start_frame' in validated_data:
+        instance.start_frame_number = validated_data['start_frame']
+
+    if 'end_time' in validated_data:
+        if fps is None:
+            fps = _validate_fps(instance.video)
+        instance.end_frame_number = _convert_time_to_frame(validated_data['end_time'], fps)
+    elif 'end_frame' in validated_data:
+        instance.end_frame_number = validated_data['end_frame']
+
+def _update(instance: "LabelVideoSegment", validated_data: Dict[str, Any]) -> "LabelVideoSegment":
+    """
+    Handles the update logic for a LabelVideoSegment instance.
+    This function is designed to be used within a serializer's update method.
+    """
+    video: Optional["VideoFile"] = validated_data.get('video')
+    fps = None
+
+    if video and video != instance.video:
+        instance.video = video
+        fps = _validate_fps(video)  # Validate FPS for the new video
+
+    if 'label' in validated_data:
+        instance.label = validated_data['label']
+
+    _update_frames_from_data(instance, validated_data, fps)
+
+    # Final validation of frame numbers
+    if instance.start_frame_number >= instance.end_frame_number:
+        raise serializers.ValidationError("start_frame must be less than end_frame.")
+    
+    if instance.video and instance.end_frame_number > instance.video.frame_count:
+        raise serializers.ValidationError("end_frame cannot exceed the total frames of the video.")
+
+    instance.save()
+    return instance
+
+def _update(self:"LabelVideoSegmentSerializer", instance, validated_data):
+    """
+    Update a LabelVideoSegment instance with new validated data.
+    
+    This method updates the associated video file, label (by ID or name), and segment boundaries (start and end times converted to frame numbers based on the video's FPS). If the referenced video or label does not exist, or if any error occurs during the update, a validation error is raised.
+    
+    Returns:
+        The updated LabelVideoSegment instance.
+    """
+    try:
+        # Handle time-based updates
+        start_time = validated_data.pop('start_time', None)
+        end_time = validated_data.pop('end_time', None)
+        video_id = validated_data.pop('video_id', None)
+        label_id = validated_data.pop('label_id', None)
+        label_name = validated_data.pop('label_name', None)
+        
+        # Update video if provided
+        if video_id and (not instance.video_file or video_id != instance.video_file.id):
+            try:
+                instance.video_file = VideoFile.objects.get(id=video_id)
+            except ObjectDoesNotExist as exc:
+                raise serializers.ValidationError(f"VideoFile with id {video_id} does not exist") from exc
+        
+        # Update label if provided
+        if label_id is not None:
+            if label_id:
+                try:
+                    instance.label = Label.objects.get(id=label_id)
+                except ObjectDoesNotExist as exc:
+                    raise serializers.ValidationError(f"Label with id {label_id} does not exist") from exc
+            else:
+                instance.label = None
+        elif label_name is not None:
+            if label_name:
+                instance.label = self.get_or_create_label_from_name(label_name)
+            else:
+                instance.label = None
+        
+        def _get_valid_fps(video_file):
+            """
+            Extract and validate the frames-per-second (FPS) value from a video file object.
+            
+            Returns:
+                float: The FPS value as a positive float. Defaults to 30.0 if missing, invalid, or non-positive.
+            """
+
+        # Convert time to frame numbers if provided
+        if start_time is not None:
+            fps = _validate_fps(instance.video_file)
+            instance.start_frame_number = _convert_time_to_frame(start_time, fps)
+        
+        if end_time is not None:
+            fps = _validate_fps(instance.video_file)
+            instance.end_frame_number = _convert_time_to_frame(end_time, fps)
+        
+        # Update other fields
+        for attr, value in validated_data.items():
+            setattr(instance, attr, value)
+        
+        instance.save()
+        logger.info("Updated video segment: %s", instance.pk)
+        return instance
+        
+    except Exception as e:
+        logger.error("Error updating video segment %s: %s", instance.pk, str(e))
+        raise serializers.ValidationError(f"Failed to update segment: {str(e)}")
+