endoreg-db 0.8.8.0__py3-none-any.whl → 0.8.9.2__py3-none-any.whl

endoreg_db/serializers/_old/raw_pdf_meta_validation.py

@@ -1,223 +0,0 @@
-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

@@ -1,179 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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/meta/pdf_file_meta_extraction.py

@@ -1,115 +0,0 @@
-from pathlib import Path
-from rest_framework import serializers
-from django.conf import settings
-from ...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 not None:
-            try:
-                query_filter = {"id__gt": int(last_id)}
-            except ValueError:
-                # If last_id is not a valid integer, treat it as if no ID was provided.
-                # This prevents a crash and safely defaults to fetching the first PDF.
-                query_filter = {}
-
-        # 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 an absolute URL for accessing the PDF associated with the given object.
-        
-        Returns:
-            The full URL as a string if the file exists; otherwise, None.
-        """
-        request = self.context.get('request')
-        print("---------------------here :",obj.file)
-        if request and obj.file:
-            return request.build_absolute_uri(f"/pdf/sensitivemeta/?id={obj.id}")  # Constructs full API endpoint
-        return None  # Return None if file is missing
-
-    def get_file(self, obj):
-        """
-        Retrieves the relative file path of the PDF from the database.
-        
-        Returns:
-            The relative file path as a string, or None if no file is linked.
-        """
-        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):
-        """
-        Validate input data to ensure a PDF file is provided and the referenced sensitive_meta_id exists.
-        
-        Raises:
-            serializers.ValidationError: If the PDF file is missing or the sensitive_meta_id does not correspond to an existing SensitiveMeta record.
-        
-        Returns:
-            dict: The validated input data if all checks pass.
-        """
-        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
-
-
-

endoreg_db/serializers/meta/report_meta.py

@@ -1,53 +0,0 @@
-from endoreg_db.models import SensitiveMeta
-
-
-from django.utils import timezone
-from rest_framework import serializers
-
-
-class ReportMetaSerializer(serializers.ModelSerializer):
-    """
-    Serializer für Report-Metadaten basierend auf SensitiveMeta
-    """
-    # Füge fehlende Zeitstempel-Felder hinzu
-    created_at = serializers.SerializerMethodField()
-    updated_at = serializers.SerializerMethodField()
-    casenumber = serializers.CharField(source='casenumber', allow_blank=True, allow_null=True)
-
-    class Meta:
-        model = SensitiveMeta
-        fields = [
-            'id', 'patient_first_name', 'patient_last_name',
-            'patient_gender', 'patient_dob', 'examination_date',
-            'casenumber', 'created_at', 'updated_at'
-        ]
-
-    def get_created_at(self, obj):
-        """
-        Retrieve the `created_at` timestamp from the SensitiveMeta instance, or return the current time if unavailable.
-        
-        Parameters:
-            obj: The SensitiveMeta instance being serialized.
-        
-        Returns:
-            datetime: The `created_at` timestamp, or the current time as a fallback.
-        """
-        if hasattr(obj, 'created_at') and obj.created_at:
-            return obj.created_at
-        # Fallback wenn SensitiveMeta kein created_at hat
-        return timezone.now()
-
-    def get_updated_at(self, obj):
-        """
-        Return the `updated_at` timestamp from the SensitiveMeta instance, or fall back to the `created_at` timestamp if `updated_at` is missing or null.
-        
-        Parameters:
-            obj: The SensitiveMeta instance being serialized.
-        
-        Returns:
-            A datetime representing when the instance was last updated, or created if no update timestamp is available.
-        """
-        if hasattr(obj, 'updated_at') and obj.updated_at:
-            return obj.updated_at
-        # Fallback wenn SensitiveMeta kein updated_at hat  
-        return self.get_created_at(obj)

endoreg_db/serializers/report/__init__.py

@@ -1,9 +0,0 @@
-from .report_list import ReportListSerializer
-from .report import ReportDataSerializer
-from .secure_file_url import SecureFileUrlSerializer
-
-__all__ = [
-    "ReportListSerializer",
-    "ReportDataSerializer",
-    "SecureFileUrlSerializer"
-]