endoreg-db 0.8.6.1__py3-none-any.whl → 0.8.8.9__py3-none-any.whl

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='case_number', 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"
-]

endoreg_db/serializers/report/mixins.py

@@ -1,45 +0,0 @@
-from pathlib import Path
-from typing import TYPE_CHECKING, Literal
-from django.utils import timezone
-
-if TYPE_CHECKING:
-    from endoreg_db.models import RawPdfFile
-
-class ReportStatusMixin:
-    """
-    Mixin class for report serializers to provide status, updated_at, and file_type fields.
-    """
-
-    def get_status(self, obj:"RawPdfFile") -> Literal['approved'] | Literal['pending']:
-        """
-        Return the report status as 'approved' if the report has been processed, otherwise 'pending'.
-        
-        Parameters:
-            obj (RawPdfFile): The report file instance to check.
-        
-        Returns:
-            Literal['approved'] | Literal['pending']: The status of the report based on its processing state.
-        """
-        if obj.state_report_processed:
-            return 'approved'
-        if obj.state_report_processing_required:
-            return 'pending'
-        return 'pending'
-
-    def get_updated_at(self, obj:"RawPdfFile") -> "timezone.datetime":
-        """
-        Return the last update time for the given RawPdfFile object.
-        
-        If the object's creation date is available, it is returned; otherwise, the current time is used.
-        """
-        return obj.date_created if obj.date_created else timezone.now()
-
-    def get_file_type(self, obj:"RawPdfFile"    ) -> "str":
-        """
-        Return the file type of the associated file as a lowercase string without the leading dot.
-        
-        If the object has no file, returns 'unknown'.
-        """
-        if obj.file:
-            return Path(obj.file.name).suffix.lower().lstrip('.')
-        return 'unknown'

endoreg_db/serializers/report/report.py

@@ -1,105 +0,0 @@
-from endoreg_db.models import RawPdfFile
-from endoreg_db.serializers.meta.report_meta import ReportMetaSerializer
-from endoreg_db.serializers.report.secure_file_url import SecureFileUrlSerializer
-from endoreg_db.serializers.report.mixins import ReportStatusMixin
-
-from django.utils import timezone
-from rest_framework import serializers
-
-
-import uuid
-from datetime import timedelta
-from pathlib import Path
-
-
-class ReportDataSerializer(ReportStatusMixin, serializers.ModelSerializer):
-    """
-    Hauptserializer für Report-Daten mit sicherer URL
-    """
-    report_meta = ReportMetaSerializer(source='sensitive_meta', read_only=True)
-    secure_file_url = SecureFileUrlSerializer(read_only=True)
-    file_type = serializers.SerializerMethodField()
-
-    # Status und updated_at hinzufügen (da sie im RawPdfFile Model fehlen)
-    status = serializers.SerializerMethodField()
-    updated_at = serializers.SerializerMethodField()
-
-    class Meta:
-        model = RawPdfFile
-        fields = [
-            'id', 'anonymized_text', 'status', 'report_meta',
-            'secure_file_url', 'file_type', 'created_at', 'updated_at'
-        ]
-
-    def get_updated_at(self, obj):
-        """
-        Return the updated timestamp for the object, using `created_at` if available or the current time otherwise.
-        """
-        return obj.created_at if obj.created_at else timezone.now()
-
-    def get_file_type(self, obj):
-        """
-        Return the file extension of the associated file in lowercase, or 'unknown' if no file is present.
-        
-        Parameters:
-            obj: The object instance containing the file.
-        
-        Returns:
-            str: The file extension without the leading dot, or 'unknown' if the file is missing.
-        """
-        if obj.file:
-            return Path(obj.file.name).suffix.lower().lstrip('.')
-        return 'unknown'
-
-    def to_representation(self, instance):
-        """
-        Returns the serialized representation of the instance, including a secure file URL if a file exists and a request context is available.
-        """
-        data = super().to_representation(instance)
-
-        # Sichere URL generieren wenn file vorhanden
-        if instance.file and hasattr(instance.file, 'url'):
-            request = self.context.get('request')
-            if request:
-                # Sichere URL mit Token generieren
-                secure_url_data = self._generate_secure_url(instance, request)
-                data['secure_file_url'] = secure_url_data
-
-        return data
-
-    def _generate_secure_url(self, instance, request):
-        """
-        Generate a secure URL for downloading the file associated with the given instance, including an expiration time and file metadata.
-        
-        Parameters:
-            instance: The model instance containing the file.
-            request: The HTTP request object used to build the absolute URL.
-        
-        Returns:
-            dict: A dictionary containing the secure URL, expiration timestamp, file type, original filename, and file size in bytes.
-        """
-        # Token für sichere URL generieren
-        token = str(uuid.uuid4())
-        expires_at = timezone.now() + timedelta(hours=2)  # 2 Stunden gültig
-
-        # URL zusammenbauen
-        secure_url = request.build_absolute_uri(
-            f"/api/reports/{instance.id}/secure-file/?token={token}"
-        )
-
-        # Dateigröße ermitteln
-        file_size = 0
-        try:
-            if instance.file:
-                file_size = instance.file.size
-        except OSError:
-            # Datei nicht verfügbar oder Berechtigung fehlt
-            file_size = 0
-
-        return {
-            'url': secure_url,
-            'expires_at': expires_at,
-            'file_type': self.get_file_type(instance),
-            'original_filename': Path(instance.file.name).name if instance.file else 'unknown',
-            'file_size': file_size
-        }

endoreg_db/serializers/report/report_list.py

@@ -1,22 +0,0 @@
-from endoreg_db.models import RawPdfFile
-from endoreg_db.serializers.meta import ReportMetaSerializer
-from endoreg_db.serializers.report.mixins import ReportStatusMixin
-
-from django.utils import timezone
-from rest_framework import serializers
-
-
-from pathlib import Path
-
-
-class ReportListSerializer(ReportStatusMixin, serializers.ModelSerializer):
-    """
-    Vereinfachter Serializer für Report-Listen
-    """
-    report_meta = ReportMetaSerializer(source='sensitive_meta', read_only=True)
-    file_type = serializers.SerializerMethodField()
-    updated_at = serializers.SerializerMethodField()
-
-    class Meta:
-        model = RawPdfFile
-        fields = ['id', 'status', 'report_meta', 'file_type', 'created_at', 'updated_at']

endoreg_db/serializers/report/secure_file_url.py

@@ -1,26 +0,0 @@
-from rest_framework import serializers
-
-
-class SecureFileUrlSerializer(serializers.Serializer):
-    """
-    Serializer für sichere File-URLs mit Ablaufzeit
-    """
-    url = serializers.URLField()
-    expires_at = serializers.DateTimeField()
-    file_type = serializers.CharField(max_length=20)
-    original_filename = serializers.CharField(max_length=255)
-    file_size = serializers.IntegerField()
-
-    def create(self, validated_data):
-        # Nicht implementiert, da nur für Ausgabe verwendet
-        """
-        Raises NotImplementedError to indicate that instance creation is not supported for this serializer.
-        """
-        raise NotImplementedError("SecureFileUrlSerializer ist nur für Ausgabe gedacht")
-
-    def update(self, instance, validated_data):
-        # Nicht implementiert, da nur für Ausgabe verwendet  
-        """
-        Raises NotImplementedError to indicate that updating is not supported, as this serializer is intended for output only.
-        """
-        raise NotImplementedError("SecureFileUrlSerializer ist nur für Ausgabe gedacht")