endoreg-db 0.4.5__py3-none-any.whl → 0.8.6.3__py3-none-any.whl

endoreg_db/serializers/__init__.py

@@ -1,10 +1,118 @@
-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 (
+    ActiveModelSerializer,
+    AiModelSerializer,
+    CenterSerializer,
+    GenderSerializer,
+    ModelTypeSerializer,
+)
+from .examination import (
+    ExaminationDropdownSerializer,
+    ExaminationSerializer,
+    ExaminationTypeSerializer,
+)
+from .finding import FindingSerializer
+from .finding_classification import (
+    FindingClassificationChoiceSerializer,
+    FindingClassificationSerializer,
+)
+from .label import ImageClassificationAnnotationSerializer, LabelSerializer
+from .label_video_segment import (
+    LabelVideoSegmentAnnotationSerializer,
+    LabelVideoSegmentSerializer,
+)
+from .meta import (
+    PDFFileForMetaSerializer,
+    ReportMetaSerializer,
+    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 .report import ReportDataSerializer, ReportListSerializer, SecureFileUrlSerializer
+from .video.video_metadata import VideoMetadataSerializer
+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",
+    "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",
+    # Video Examination
+    "VideoExaminationSerializer",
+    "VideoExaminationCreateSerializer",
+    "VideoExaminationUpdateSerializer",
+]

endoreg_db/serializers/_old/raw_pdf_meta_validation.py

@@ -0,0 +1,223 @@
+from pathlib import Path
+from rest_framework import serializers
+from django.conf import settings
+#from ...models import RawPdfFile, SensitiveMeta
+from endoreg_db.models import RawPdfFile, SensitiveMeta
+
+class PDFFileForMetaSerializer(serializers.ModelSerializer):
+    """
+    Serializer to fetch PDF metadata along with linked `SensitiveMeta` details.
+    Implements validation and ensures Vue.js can process errors easily.
+    """
+
+    # Fetch patient details from `SensitiveMeta`
+    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.CharField(source="sensitive_meta.patient_dob", read_only=True)
+    examination_date = serializers.CharField(source="sensitive_meta.examination_date", read_only=True)
+
+    # PDF file URL where Vue.js can fetch the document
+    pdf_url = serializers.SerializerMethodField()
+
+    # Full absolute path of the PDF file
+    full_pdf_path = serializers.SerializerMethodField()
+
+    # Direct file path from the database
+    file = serializers.SerializerMethodField()
+
+    class Meta:
+        model = RawPdfFile
+        fields = ['id', 'file', 'pdf_url', 'full_pdf_path', 
+                  'sensitive_meta_id', 'patient_first_name', 
+                  'patient_last_name', 'patient_dob', 'examination_date']
+
+    @staticmethod
+    def get_next_pdf(last_id=None):
+        """
+        Retrieves the first available PDF if `last_id` is NOT provided.
+        Otherwise, fetches the next available PDF where `id > last_id`.
+        """
+        query_filter = {} if last_id is None else {"id__gt": int(last_id)}
+
+        # Get the next available PDF
+        pdf_entry = RawPdfFile.objects.select_related("sensitive_meta").filter(**query_filter).order_by('id').first()
+
+        return pdf_entry  # Returns a model instance or None
+
+    def get_pdf_url(self, obj):
+        """
+        Generates the full URL for Vue.js to fetch and display the PDF.
+        """
+        request = self.context.get('request')
+        print("---------------------here :",obj.file)
+        if request and obj.file:
+            return request.build_absolute_uri(f"/api/pdf/sensitivemeta/?id={obj.id}")  # Constructs full API endpoint
+        return None  # Return None if file is missing
+
+    def get_file(self, obj):
+        """
+        Returns the relative file path stored in the database.
+        """
+        if not obj.file:
+            return None  # No file linked
+        return str(obj.file.name).strip()  # Ensures clean output
+
+    def get_full_pdf_path(self, obj):
+        """
+        Constructs the full absolute file path using `settings.MEDIA_ROOT`.
+        """
+        if not obj.file:
+            return None  # No file linked
+
+        pdf_relative_path = str(obj.file.name)
+
+        full_path = Path(settings.MEDIA_ROOT) / pdf_relative_path
+
+        return str(full_path) if full_path.exists() else None  # Returns path or None if file is missing
+
+    def validate(self, data):
+        """
+        Ensures that the PDF file is valid and has required fields.
+        """
+        errors = {}
+
+        if 'file' in data and not data['file']:
+            errors['file'] = "A valid PDF file is required."
+
+        if 'sensitive_meta_id' in data and not SensitiveMeta.objects.filter(id=data['sensitive_meta_id']).exists():
+            errors['sensitive_meta_id'] = "The provided sensitive_meta_id does not exist."
+
+        if errors:
+            raise serializers.ValidationError(errors)  # Returns structured error response
+
+        return data  # Returns validated data
+
+
+from rest_framework import serializers
+#from ..models import SensitiveMeta
+
+class SensitiveMetaUpdateSerializer(serializers.ModelSerializer):
+    """
+    Serializer for updating patient details in the `SensitiveMeta` table.
+    Allows partial updates.
+    """
+
+    sensitive_meta_id = serializers.IntegerField(write_only=True)  # Needed for lookup, not included in response
+
+    class Meta:
+        model = SensitiveMeta
+        fields = ['sensitive_meta_id', 'patient_first_name', 'patient_last_name', 'patient_dob', 'examination_date']
+
+    def validate(self, data):
+        """
+        Ensures valid input before updating.
+        """
+        errors = {}
+
+        if 'patient_first_name' in data and (not data['patient_first_name'].strip()):
+            errors['patient_first_name'] = "First name cannot be empty."
+
+        if 'patient_last_name' in data and (not data['patient_last_name'].strip()):
+            errors['patient_last_name'] = "Last name cannot be empty."
+
+        if 'patient_dob' in data and not data['patient_dob']:
+            errors['patient_dob'] = "Date of birth is required."
+
+        if 'examination_date' in data and not data['examination_date']:
+            errors['examination_date'] = "Examination date is required."
+
+        if errors:
+            raise serializers.ValidationError(errors)
+
+        return data
+
+    def update(self, instance, validated_data):
+        """
+        Updates only the provided fields dynamically.
+        """
+        validated_data.pop("sensitive_meta_id", None)  # Remove ID before updating
+
+        for attr, value in validated_data.items():
+            setattr(instance, attr, value)  # Dynamically update fields
+
+        instance.save()
+        return instance
+
+
+
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+const fetchPdfMeta = async (lastId = 1) => {
+    const url = lastId 
+        ? `http://localhost:8000/api/pdf/sensitivemeta/?last_id=${lastId}` 
+        : "http://localhost:8000/api/pdf/sensitivemeta/";
+
+    try {
+        const response = await axios.get(url);
+        console.log("PDF Metadata:", response.data);
+    } catch (error) {
+        console.error("Error fetching PDFs:", error.response?.data || error);
+    }
+};
+
+fetchPdfMeta(); // Fetch the first available PDF
+
+"""
+
+"""with header response"""
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+
+const fetchPdfMeta = async (lastId = 1) => {
+    const url = lastId 
+        ? `http://localhost:8000/api/pdf/sensitivemeta/?last_id=${lastId}` 
+        : "http://localhost:8000/api/pdf/sensitivemeta/";
+
+    try {
+        const response = await axios.get(url, {
+            headers: {
+                "Accept": "application/json"  
+            }
+        });
+
+        console.log("PDF Metadata (JSON Expected):", response.data);
+    } catch (error) {
+        console.error("Error fetching PDFs:", error.response?.data || error);
+    }
+};
+
+fetchPdfMeta(); 
+"""
+
+
+"""
+await import('https://cdn.jsdelivr.net/npm/axios/dist/axios.min.js');
+
+const updatePatientInfo = async () => {
+    const updatedData = {
+        sensitive_meta_id: 1,
+        patient_first_name: "dummy value",
+        patient_last_name: "dummy value",
+        patient_dob: "1994-06-15",
+        examination_date: "2024-06-15"
+    };
+
+    try {
+        const response = await axios.patch("http://localhost:8000/api/pdf/update_sensitivemeta/", updatedData, {
+            headers: { "Content-Type": "application/json" }
+        });
+
+        console.log("Update Success:", response.data);
+        alert("Patient information updated successfully!");
+
+        return response.data;
+    } catch (error) {
+        console.error("Update Error:", error.response?.data || error);
+        alert("Failed to update patient information.");
+        return error.response?.data || { error: "Unknown error" };
+    }
+};
+
+updatePatientInfo().then(response => console.log("Final Response:", response));
+
+"""

endoreg_db/serializers/_old/raw_video_meta_validation.py

@@ -0,0 +1,179 @@
+from pathlib import Path
+from rest_framework import serializers
+from django.conf import settings
+from ...models import VideoFile, SensitiveMeta
+import cv2
+
+
+class VideoFileForMetaSerializer(serializers.ModelSerializer):
+    """
+    Serializer to fetch video metadata along with linked `SensitiveMeta` details.
+    Ensures that Vue.js can properly access and play videos.
+    """
+
+    # Fetch patient name and DOB from `SensitiveMeta` table
+    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.CharField(source="sensitive_meta.patient_dob", read_only=True)
+    examination_date = serializers.CharField(source="sensitive_meta.examination_date", read_only=True)
+
+    duration = serializers.SerializerMethodField()
+
+
+    # `video_url` generates the full URL where Vue.js can fetch & play the video
+    video_url = serializers.SerializerMethodField()
+
+    # `full_video_path` dynamically constructs the absolute path using MEDIA_ROOT
+    full_video_path = serializers.SerializerMethodField()
+    
+    file = serializers.SerializerMethodField()
+
+    class Meta:
+        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']
+
+    @staticmethod
+    def get_next_video(last_id=None):
+        """
+        Fetches the first or next available video.
+        Returns a model instance if found, else returns None.
+        """
+        query_filter = {} if last_id is None else {"id__gt": int(last_id)}
+
+        # Get next available video
+        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):
+        """
+        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.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 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.processed_file:
+            return None  # No file associated
+
+        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):
+        """
+        Constructs the full absolute file path using `settings.MEDIA_ROOT` 
+        and the `file` field from the database.
+        """
+        if not obj.processed_file:
+            return None  # No file associated
+
+        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
+
+    def get_duration(self, obj):
+        """
+        Returns the total duration of the video in seconds.
+        - If stored in the database, use it.
+        - Otherwise, calculate dynamically using OpenCV.
+        """
+        
+        # Step 1: Check if the `duration` field is already stored in the database.
+        if hasattr(obj, "duration") and obj.duration:
+            return obj.duration  # If duration exists in the database, return it immediately.
+
+        # Step 2: Get the actual video file path
+        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():
+            return None  # Return None if the file path is invalid or missing
+
+        # Step 4: Open the video file using OpenCV
+        cap = cv2.VideoCapture(video_path)  # Load the video file
+
+        if not cap.isOpened():
+            return None  # If OpenCV fails to open the video, return None (invalid or corrupted file)
+
+        # Step 5: Extract FPS (Frames Per Second)
+        fps = cap.get(cv2.CAP_PROP_FPS)  # Get the number of frames per second
+        print("here is the fps------------", fps)  # Debugging print to check FPS value
+
+        # Step 6: Get Total Number of Frames
+        total_frames = cap.get(cv2.CAP_PROP_FRAME_COUNT)  # Get the total number of frames in the video
+
+        # Step 7: Release the video file from OpenCV memory
+        cap.release()  # Free up system memory
+
+        # Step 8: Calculate and Return Video Duration
+        return round(total_frames / fps, 2) if fps > 0 else None  # Divide frames by FPS to get duration (seconds)
+        
+
+
+
+class SensitiveMetaUpdateSerializer(serializers.ModelSerializer):
+    """
+    Serializer to update patient information in the `SensitiveMeta` table.
+    Handles validation and saves the data directly in the serializer.
+    """
+
+    sensitive_meta_id = serializers.IntegerField(write_only=True)  # Needed for lookup but not included in response
+
+    class Meta:
+        model = SensitiveMeta
+        fields = ['sensitive_meta_id', 'patient_first_name', 'patient_last_name', 'patient_dob', 'examination_date']
+
+    def validate(self, data):
+        """
+        Validate input data before updating.
+        """
+        errors = {}
+
+        # Ensure the SensitiveMeta ID exists
+        sensitive_meta_id = data.get("sensitive_meta_id")
+        if not SensitiveMeta.objects.filter(id=sensitive_meta_id).exists():
+            raise serializers.ValidationError({"sensitive_meta_id": "SensitiveMeta entry not found."})
+
+        # Validate each field separately
+        if 'patient_first_name' in data and (data['patient_first_name'] is None or data['patient_first_name'].strip() == ""):
+            errors['patient_first_name'] = "First name cannot be empty."
+
+        if 'patient_last_name' in data and (data['patient_last_name'] is None or data['patient_last_name'].strip() == ""):
+            errors['patient_last_name'] = "Last name cannot be empty."
+
+        if 'patient_dob' in data and not data['patient_dob']:
+            errors['patient_dob'] = "Date of birth is required."
+
+        if 'examination_date' in data and not data['examination_date']:
+            errors['examination_date'] = "Examination date is required."
+
+        if errors:
+            raise serializers.ValidationError(errors)  # Raise errors before saving
+
+        return data
+
+    def update(self, instance, validated_data):
+        """
+        Update the SensitiveMeta entry directly inside the serializer.
+        """
+        # Remove `sensitive_meta_id` before updating
+        validated_data.pop("sensitive_meta_id", None)
+
+        for attr, value in validated_data.items():
+            setattr(instance, attr, value)  # Set attributes dynamically
+
+        instance.save()  # Save changes
+        return instance  # Return updated instance

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']