endoreg-db 0.8.9.32__py3-none-any.whl

endoreg_db/serializers/__init__.py

@@ -0,0 +1,104 @@
+from .administration import (
+    ActiveModelSerializer,
+    AiModelSerializer,
+    CenterSerializer,
+    GenderSerializer,
+    ModelTypeSerializer,
+)
+from .examination import (
+    ExaminationDropdownSerializer,
+    ExaminationSerializer,
+    ExaminationTypeSerializer,
+)
+from .finding import FindingSerializer
+from .finding_classification import (
+    FindingClassificationSerializer,  # FindingClassificationChoiceSerializer,
+)
+from .label_video_segment import (
+    ImageClassificationAnnotationSerializer,
+    LabelSerializer,
+    LabelVideoSegmentSerializer,
+)
+from .meta import (
+    SensitiveMetaDetailSerializer,
+    SensitiveMetaUpdateSerializer,
+    SensitiveMetaVerificationSerializer,
+    VideoMetaSerializer,
+)
+from .misc import (
+    FileOverviewSerializer,
+    StatsSerializer,
+    TranslatableFieldMixin,
+    UploadCreateResponseSerializer,
+    UploadJobStatusSerializer,
+    VoPPatientDataSerializer,
+)
+from .patient import PatientDropdownSerializer, PatientSerializer
+from .patient_examination import PatientExaminationSerializer
+from .patient_finding import (
+    PatientFindingClassificationSerializer,
+    PatientFindingDetailSerializer,
+    PatientFindingInterventionSerializer,
+    PatientFindingListSerializer,
+    PatientFindingSerializer,
+    PatientFindingWriteSerializer,
+)
+from .pdf import RawPdfAnonyTextSerializer
+from .video.video_processing_history import VideoProcessingHistorySerializer
+from .video_examination import (
+    VideoExaminationCreateSerializer,
+    VideoExaminationSerializer,
+    VideoExaminationUpdateSerializer,
+)
+
+__all__ = [
+    # Administration
+    "CenterSerializer",
+    "GenderSerializer",
+    "ActiveModelSerializer",
+    "ModelTypeSerializer",
+    "AiModelSerializer",
+    # Examination
+    "ExaminationSerializer",
+    "ExaminationTypeSerializer",
+    "ExaminationDropdownSerializer",
+    # Finding
+    "FindingSerializer",
+    "FindingClassificationSerializer",
+    "LabelSerializer",
+    "ImageClassificationAnnotationSerializer",
+    # LabelVideoSegment
+    "LabelVideoSegmentSerializer",
+    # Meta
+    "SensitiveMetaDetailSerializer",
+    "SensitiveMetaUpdateSerializer",
+    "SensitiveMetaVerificationSerializer",
+    "VideoMetaSerializer",
+    # Misc
+    "FileOverviewSerializer",
+    "VoPPatientDataSerializer",
+    "StatsSerializer",
+    "UploadJobStatusSerializer",
+    "UploadCreateResponseSerializer",
+    "TranslatableFieldMixin",
+    # Patient
+    "PatientSerializer",
+    "PatientDropdownSerializer",
+    # Patient Examination
+    "PatientExaminationSerializer",
+    # Patient Finding
+    "PatientFindingSerializer",
+    "PatientFindingClassificationSerializer",
+    "PatientFindingDetailSerializer",
+    "PatientFindingInterventionSerializer",
+    "PatientFindingListSerializer",
+    "PatientFindingWriteSerializer",
+    # report
+    "RawPdfAnonyTextSerializer",
+    # Video Correction (Phase 1.1)
+    "VideoProcessingHistorySerializer",
+    # Video Examination
+    "VideoExaminationSerializer",
+    "VideoExaminationCreateSerializer",
+    "VideoExaminationUpdateSerializer",
+]

endoreg_db/serializers/administration/__init__.py

@@ -0,0 +1,13 @@
+from .center import CenterSerializer
+from .gender import GenderSerializer
+from .ai import ActiveModelSerializer, ModelTypeSerializer, AiModelSerializer
+
+__all__ = [
+    # AI
+    "ActiveModelSerializer",
+    "ModelTypeSerializer",
+    "AiModelSerializer",
+    # Misc
+    "CenterSerializer",
+    "GenderSerializer",
+]

endoreg_db/serializers/administration/ai/__init__.py

@@ -0,0 +1,9 @@
+from .active_model import ActiveModelSerializer
+from .model_type import ModelTypeSerializer
+from .ai_model import AiModelSerializer
+
+__all__ = [
+    "ActiveModelSerializer",
+    "ModelTypeSerializer",
+    "AiModelSerializer",
+]

endoreg_db/serializers/administration/ai/active_model.py

@@ -0,0 +1,12 @@
+from rest_framework import serializers
+from endoreg_db.models import ActiveModel
+
+
+class ActiveModelSerializer(serializers.ModelSerializer):
+    """
+    Serializer for the ActiveModel model.
+    """
+
+    class Meta:
+        model = ActiveModel
+        fields = "__all__"

endoreg_db/serializers/administration/ai/ai_model.py

@@ -0,0 +1,20 @@
+from rest_framework import serializers
+from endoreg_db.models import AiModel, ModelType
+
+
+class AiModelSerializer(serializers.ModelSerializer):
+    """
+    Serializer for the AiModel model.
+    Handles 'model_type' relationship by its name.
+    """
+
+    model_type = serializers.SlugRelatedField(
+        queryset=ModelType.objects.all(),
+        slug_field="name",
+        allow_null=True,  # Match model field definition
+        required=False,  # Match model field definition (blank=True)
+    )
+
+    class Meta:
+        model = AiModel
+        fields = "__all__"

endoreg_db/serializers/administration/ai/model_type.py

@@ -0,0 +1,12 @@
+from rest_framework import serializers
+from endoreg_db.models import ModelType
+
+
+class ModelTypeSerializer(serializers.ModelSerializer):
+    """
+    Serializer for the ModelType model.
+    """
+
+    class Meta:
+        model = ModelType
+        fields = "__all__"

endoreg_db/serializers/administration/center.py

@@ -0,0 +1,14 @@
+from rest_framework import serializers
+from endoreg_db.models import Center
+
+
+class CenterSerializer(serializers.ModelSerializer):
+    """Serializer für Center-Modell"""
+
+    class Meta:
+        model = Center
+        fields = [
+            "id",
+            "name",
+        ]
+        read_only_fields = ["id"]

endoreg_db/serializers/administration/gender.py

@@ -0,0 +1,11 @@
+from rest_framework import serializers
+from endoreg_db.models import Gender
+
+
+class GenderSerializer(serializers.ModelSerializer):
+    """Serializer für Gender-Modell"""
+
+    class Meta:
+        model = Gender
+        fields = ["id", "name", "abbreviation", "description"]
+        read_only_fields = ["id"]

endoreg_db/serializers/anonymization.py

@@ -0,0 +1,77 @@
+"""
+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=True, allow_blank=True)
+    patient_last_name = serializers.CharField(required=True, allow_blank=True)
+    patient_dob = serializers.CharField(required=True, allow_blank=True)
+    examination_date = serializers.CharField(required=True, allow_blank=True)
+    casenumber = serializers.CharField(required=True, 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"
+    center_name = serializers.CharField(required=False, allow_blank=True)
+    external_id = serializers.CharField(required=False, allow_blank=True)
+    external_id_origin = serializers.CharField(required=False, allow_blank=True)
+
+    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 value == "" or not value:
+            raise serializers.ValidationError(
+                "Ungültiges Datum. Kein Input! Erlaubte Formate: DD.MM.YYYY oder YYYY-MM-DD."
+            )
+
+        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 value == "" or not value:
+            raise serializers.ValidationError(
+                "Ungültiges Datum. Kein Input! Erlaubte Formate: DD.MM.YYYY oder YYYY-MM-DD."
+            )
+
+        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/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,45 @@
+# 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,20 @@
+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,9 @@
+# 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,61 @@
+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,11 @@
+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_video_segment/__init__.py

@@ -0,0 +1,9 @@
+from .label_video_segment import LabelVideoSegmentSerializer
+from .image_classification_annotation import ImageClassificationAnnotationSerializer
+from .label.label import LabelSerializer
+
+__all__ = [
+    "LabelVideoSegmentSerializer",
+    "LabelSerializer",
+    "ImageClassificationAnnotationSerializer",
+]

endoreg_db/serializers/label_video_segment/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_video_segment/label/__init__.py

@@ -0,0 +1,6 @@
+from .label import LabelSerializer
+
+
+__all__ = [
+    "LabelSerializer",
+]

endoreg_db/serializers/label_video_segment/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"]