endoreg-db 0.6.3__py3-none-any.whl → 0.8.1__py3-none-any.whl

endoreg_db/serializers/__init__.py

@@ -1,10 +1,147 @@
-from .ai_model import *
-from .annotation import *
-from .center import *
-from .examination import *
-from .frame import *
-from .hardware import *
-from .label import *
-from .patient import *
-from .report_file import *
-from .video import *
+from .administration import (
+    CenterSerializer,
+    GenderSerializer,
+    ActiveModelSerializer,
+    ModelTypeSerializer,
+    AiModelSerializer
+)
+
+from .examination import (
+    ExaminationSerializer,
+    ExaminationTypeSerializer,
+    ExaminationDropdownSerializer
+)
+
+from .finding import FindingSerializer
+
+from .finding_classification import (
+    FindingClassificationChoiceSerializer,
+    FindingClassificationSerializer
+)
+
+from .label import (
+    LabelSerializer,
+    ImageClassificationAnnotationSerializer
+)
+
+from .label_video_segment import (
+    LabelVideoSegmentSerializer,
+    LabelVideoSegmentAnnotationSerializer,
+)
+
+from .meta import (
+    ReportMetaSerializer,
+    PDFFileForMetaSerializer,
+    SensitiveMetaDetailSerializer,
+    SensitiveMetaUpdateSerializer,
+    SensitiveMetaVerificationSerializer,
+    VideoMetaSerializer,
+)
+
+from .misc import (
+    FileOverviewSerializer,
+    VoPPatientDataSerializer,
+    StatsSerializer,
+    UploadJobStatusSerializer,
+    UploadCreateResponseSerializer,
+    TranslatableFieldMixin
+)
+
+from .patient import (
+    PatientSerializer,
+    PatientDropdownSerializer,
+)
+
+from .patient_examination import (
+    PatientExaminationSerializer,
+)
+
+from .patient_finding import (
+    PatientFindingSerializer,
+    PatientFindingClassificationSerializer,
+    PatientFindingDetailSerializer,
+    PatientFindingInterventionSerializer,
+    PatientFindingListSerializer,
+    PatientFindingWriteSerializer,
+)
+
+from .pdf import (
+    RawPdfAnonyTextSerializer
+)
+from .report import (
+    ReportListSerializer,
+    ReportDataSerializer,
+    SecureFileUrlSerializer
+)
+
+from .video.video_metadata import VideoMetadataSerializer
+from .video.video_processing_history import VideoProcessingHistorySerializer
+
+__all__ = [
+    # Administration
+    "CenterSerializer",
+    "GenderSerializer",
+    "ActiveModelSerializer",
+    "ModelTypeSerializer",
+    "AiModelSerializer",
+
+    # Examination
+    "ExaminationSerializer",
+    "ExaminationTypeSerializer",
+    "ExaminationDropdownSerializer",
+
+    # Finding
+    'FindingSerializer',
+    'FindingClassificationSerializer',
+    "FindingClassificationChoiceSerializer",
+
+    "LabelSerializer",
+    "ImageClassificationAnnotationSerializer",
+
+    # LabelVideoSegment
+    "LabelVideoSegmentSerializer",
+    "LabelVideoSegmentAnnotationSerializer",
+
+    # Meta
+    "PDFFileForMetaSerializer",
+    "ReportMetaSerializer",
+    "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",
+
+    # PDF
+    "RawPdfAnonyTextSerializer",
+
+    # Report
+    "ReportListSerializer",
+    "ReportDataSerializer",
+    "SecureFileUrlSerializer",
+
+    # Video Correction (Phase 1.1)
+    "VideoMetadataSerializer",
+    "VideoProcessingHistorySerializer",
+]

endoreg_db/serializers/{raw_pdf_meta_validation.py → _old/raw_pdf_meta_validation.py}

@@ -1,8 +1,8 @@
 from pathlib import Path
 from rest_framework import serializers
 from django.conf import settings
-from ..models import RawPdfFile, SensitiveMeta
-
+#from ...models import RawPdfFile, SensitiveMeta
+from endoreg_db.models import RawPdfFile, SensitiveMeta
 
 class PDFFileForMetaSerializer(serializers.ModelSerializer):
     """
@@ -94,7 +94,7 @@ class PDFFileForMetaSerializer(serializers.ModelSerializer):
 
 
 from rest_framework import serializers
-from ..models import SensitiveMeta
+#from ..models import SensitiveMeta
 
 class SensitiveMetaUpdateSerializer(serializers.ModelSerializer):
     """

endoreg_db/serializers/{raw_video_meta_validation.py → _old/raw_video_meta_validation.py}

@@ -1,9 +1,8 @@
 from pathlib import Path
 from rest_framework import serializers
 from django.conf import settings
-from ..models import RawVideoFile, SensitiveMeta
+from ...models import VideoFile, SensitiveMeta
 import cv2
-from datetime import datetime
 
 
 class VideoFileForMetaSerializer(serializers.ModelSerializer):
@@ -30,7 +29,7 @@ class VideoFileForMetaSerializer(serializers.ModelSerializer):
     file = serializers.SerializerMethodField()
 
     class Meta:
-        model = RawVideoFile
+        model = VideoFile
         fields = ['id', 'original_file_name', 'file', 'video_url', 'full_video_path', 
                   'sensitive_meta_id', 'patient_first_name', 'patient_last_name', 'patient_dob', 'examination_date','duration']
 
@@ -43,28 +42,33 @@ class VideoFileForMetaSerializer(serializers.ModelSerializer):
         query_filter = {} if last_id is None else {"id__gt": int(last_id)}
 
         # Get next available video
-        video_entry = RawVideoFile.objects.select_related("sensitive_meta").filter(**query_filter).order_by('id').first()
+        video_entry = VideoFile.objects.select_related("sensitive_meta").filter(**query_filter).order_by('id').first()
 
         return video_entry  # Always return model instance or None
 
     def get_video_url(self, obj):
         """
-        Generates the full URL where Vue.js can fetch and stream the video.
+        Returns the absolute URL for streaming the processed video file, or None if unavailable.
+        
+        The URL includes an "api/" prefix and is constructed only if a request context and a processed video file are present.
         """
         request = self.context.get('request')
-        if request and obj.file:
-            print("---------------------------:",obj.file)
-            return request.build_absolute_uri(f"/api/video/{obj.id}/")  # Generates full URL
+        if request and obj.processed_file:
+            print("---------------------------:",obj.processed_file)
+            return request.build_absolute_uri(f"/api/video/{obj.id}/")  # Added api/ prefix
         return None  # Return None instead of an error dictionary
     
     def get_file(self, obj):
         """
-        Returns only the relative file path, without `/media/`.
+        Returns the relative file path of the processed video, excluding the `/media/` prefix.
+        
+        Returns:
+            The relative file path as a string if available, otherwise None.
         """
-        if not obj.file:
+        if not obj.processed_file:
             return None  # No file associated
 
-        video_relative_path = str(obj.file.name).strip()
+        video_relative_path = str(obj.processed_file.name).strip()
         return video_relative_path if video_relative_path else None  # Avoids errors if the file path is empty
 
     def get_full_video_path(self, obj):
@@ -72,10 +76,10 @@ class VideoFileForMetaSerializer(serializers.ModelSerializer):
         Constructs the full absolute file path using `settings.MEDIA_ROOT` 
         and the `file` field from the database.
         """
-        if not obj.file:
+        if not obj.processed_file:
             return None  # No file associated
 
-        video_relative_path = str(obj.file.name).strip()
+        video_relative_path = str(obj.processed_file.name).strip()
         full_path = Path(settings.MEDIA_ROOT) / video_relative_path
 
         return str(full_path) if full_path.exists() else None  # Return path or None if not found
@@ -92,7 +96,7 @@ class VideoFileForMetaSerializer(serializers.ModelSerializer):
             return obj.duration  # If duration exists in the database, return it immediately.
 
         # Step 2: Get the actual video file path
-        video_path = obj.file.path if obj.file else None  # Extracts the file path if it exists
+        video_path = obj.processed_file.path if obj.processed_file else None  # Extracts the file path if it exists
 
         # Step 3: Validate if the file exists
         if not video_path or not Path(video_path).exists():

endoreg_db/serializers/_old/video.py

@@ -0,0 +1,71 @@
+from rest_framework import serializers
+from endoreg_db.models import VideoFile, VideoImportMeta, LabelVideoSegment, VideoMeta, SensitiveMeta
+# serializers/video.py
+from pathlib import Path
+from rest_framework import serializers
+from django.conf import settings
+
+from .utils import calc_duration_seconds         # wrap your OpenCV helper
+
+
+class VideoBriefSer(serializers.ModelSerializer):
+    class Meta:
+        model  = VideoFile
+        fields = ["id", "original_file_name", "sensitive_meta_id"]
+
+
+class VideoDetailSer(VideoBriefSer):
+    patient_first_name = serializers.CharField(source="sensitive_meta.patient_first_name", read_only=True)
+    patient_last_name  = serializers.CharField(source="sensitive_meta.patient_last_name",  read_only=True)
+    patient_dob        = serializers.DateField (source="sensitive_meta.patient_dob",        read_only=True)
+    examination_date   = serializers.DateField (source="sensitive_meta.examination_date",   read_only=True)
+
+    file       = serializers.SerializerMethodField()
+    full_path  = serializers.SerializerMethodField()
+    duration   = serializers.SerializerMethodField()
+    video_url  = serializers.SerializerMethodField()
+
+    class Meta(VideoBriefSer.Meta):
+        fields = VideoBriefSer.Meta.fields + [
+            "file", "full_path", "video_url",
+            "patient_first_name", "patient_last_name",
+            "patient_dob", "examination_date",
+            "duration",
+        ]
+
+    # helpers ----------------------------------------------------------
+    def get_file(self, obj):
+        f = obj.processed_file or obj.raw_file
+        return f.name if f else None
+
+    def get_full_path(self, obj):
+        f = obj.processed_file or obj.raw_file
+        return str(Path(settings.MEDIA_ROOT) / f.name) if f else None
+
+    def get_video_url(self, obj):
+        req = self.context.get("request")
+        return req.build_absolute_uri(f"/api/media/videos/{obj.pk}/") if req else None
+
+    def get_duration(self, obj):
+        return obj.duration or calc_duration_seconds(obj)
+
+
+class SensitiveMetaUpdateSer(serializers.ModelSerializer):
+    sensitive_meta_id = serializers.IntegerField(write_only=True)
+
+    class Meta:
+        model  = SensitiveMeta
+        fields = ["sensitive_meta_id", "patient_first_name",
+                  "patient_last_name", "patient_dob", "examination_date"]
+
+
+class VideoImportMetaSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = VideoImportMeta
+        fields = "__all__"
+
+
+class LabelVideoSegmentSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = LabelVideoSegment
+        fields = "__all__"

endoreg_db/serializers/administration/__init__.py

@@ -0,0 +1,14 @@
+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,10 @@
+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,10 @@
+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,18 @@
+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,10 @@
+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,9 @@
+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,9 @@
+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,66 @@
+"""
+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)
+
+    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',
+]