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

endoreg_db/serializers/label_video_segment/label_video_segment_update.py

@@ -0,0 +1,163 @@
+from django.db import transaction
+from rest_framework import serializers
+
+from endoreg_db.models import LabelVideoSegment, VideoPredictionMeta
+from endoreg_db.serializers.label_video_segment import LabelVideoSegmentSerializer
+
+import logging
+
+logger = logging.getLogger(__name__)
+class LabelSegmentUpdateSerializer(serializers.Serializer):
+    """
+    Serializer for updating label segments.
+
+    - Ensures that the segments stored in the database match exactly with what is sent from the frontend.
+    - Updates existing segments if their `start_frame_number` matches but `end_frame_number` has changed.
+    - Inserts new segments if they are not already present in the database.
+    - Deletes extra segments from the database if they are no longer in the frontend data.
+    """
+
+    video_id = serializers.IntegerField()
+    label_id = serializers.IntegerField()
+    segments = serializers.ListField(
+        child=serializers.DictField(
+            child=serializers.FloatField()  # Ensure we handle float values
+        )
+    )
+
+    def validate(self, data):
+        """
+        Validate that the input data contains a non-empty list of segments with valid frame numbers.
+        
+        Raises a validation error if any segment is missing required fields or if a segment's start frame exceeds its end frame.
+        """
+        if not data.get("segments"):
+            raise serializers.ValidationError("No segments provided.")
+
+        for segment in data["segments"]:
+            if "start_frame_number" not in segment or "end_frame_number" not in segment:
+                raise serializers.ValidationError(
+                    "Each segment must have `start_frame_number` and `end_frame_number`."
+                )
+
+            if segment["start_frame_number"] > segment["end_frame_number"]:
+                raise serializers.ValidationError(
+                    "Start frame must be less than or equal to end frame."
+                )
+
+        return data
+
+    def save(self):
+        """
+        Synchronizes label segments in the database to match the provided frontend data for a specific video and label.
+        
+        Compares incoming segments to existing database entries, updating segments with changed end frames, creating new segments as needed, and deleting segments that are no longer present. All changes are performed within a transaction to ensure consistency. Raises a validation error if no prediction metadata exists for the specified video.
+        
+        Returns:
+            dict: A dictionary containing serialized updated segments, newly created segments, and the count of deleted segments.
+        """
+
+        video_id = self.validated_data["video_id"]
+        label_id = self.validated_data["label_id"]
+        new_segments = self.validated_data["segments"] # Remove new_keys assignment
+
+        # Fetch the correct `prediction_meta_id` based on `video_id`
+        prediction_meta_entry = VideoPredictionMeta.objects.filter(
+            video_file_id=video_id # Changed from video_id to video_file_id
+        ).first()
+        if not prediction_meta_entry:
+            raise serializers.ValidationError(
+                {"error": "No prediction metadata found for this video."}
+            )
+
+        prediction_meta_id = (
+            prediction_meta_entry.id
+        )  # Get the correct prediction_meta_id
+
+        existing_segments = LabelVideoSegment.objects.filter(
+            video_file_id=video_id, label_id=label_id  # FIXED: video_file_id instead of video_id
+        )
+
+        # Convert existing segments into a dictionary for quick lookup
+        # Key format: (start_frame_number, end_frame_number)
+        existing_segments_dict = {
+            (float(seg.start_frame_number), float(seg.end_frame_number)): seg
+            for seg in existing_segments
+        }
+
+        # Prepare lists for batch processing
+        # Initialize sets to track updates and new entries
+        updated_segments = set()
+        new_entries = []
+        existing_keys = set()
+        new_keys = set()
+
+        # Iterate through the validated data to update or create label video segments
+        print(f" Before Update: Found {existing_segments.count()} existing segments.")
+        logger.debug(f"Before Update: Found %d existing segments.", existing_segments.count())
+        logger.debug(f"New Segments Received: %d", len(new_segments))
+        logger.debug(f"Using prediction_meta_id: %d", prediction_meta_id)
+        with transaction.atomic():
+            for segment in new_segments:
+                start_frame = float(segment["start_frame_number"])
+                end_frame = float(segment["end_frame_number"])
+
+                if (start_frame, end_frame) in existing_keys:
+                    # If segment with exact start_frame and end_frame already exists, no change is needed
+                    continue
+                else:
+                    # Check if a segment exists with the same start_frame but different end_frame
+                    existing_segment = LabelVideoSegment.objects.filter(
+                        video_file_id=video_id, # Changed from video_id to video_file_id
+                        label_id=label_id,
+                        start_frame_number=start_frame,
+                    ).first()
+
+                    if existing_segment:
+                        # If a segment with the same_start_frame exists but the end_frame is different, update it
+                        if float(existing_segment.end_frame_number) != end_frame:
+                            existing_segment.end_frame_number = end_frame
+                            existing_segment.save()
+                            updated_segments.append(existing_segment)
+                    else: # Added else block to create new segment if not existing
+                        new_entries.append(
+                            LabelVideoSegment(
+                                video_file_id=video_id, # Changed from video_id to video_file_id
+                                label_id=label_id,
+                                start_frame_number=start_frame,
+                                end_frame_number=end_frame,
+                                prediction_meta_id=prediction_meta_id,
+                            )
+                        )
+                        print(
+                            f" Adding new segment: Start {start_frame} → End {end_frame}"
+                        )
+
+            # Delete segments that are no longer present in the frontend data
+            # Segments to delete are those in existing_keys but not in new_keys
+            keys_to_delete = existing_keys - set((float(s['start_frame_number']), float(s['end_frame_number'])) for s in new_segments)
+            segments_to_delete_ids = [existing_segments_dict[key].id for key in keys_to_delete]
+
+            if segments_to_delete_ids:
+                LabelVideoSegment.objects.filter(id__in=segments_to_delete_ids).delete()
+                deleted_count = len(segments_to_delete_ids)
+            else:
+                deleted_count = 0
+
+            # Insert new segments in bulk for efficiency
+            if new_entries:
+                LabelVideoSegment.objects.bulk_create(new_entries)
+
+        logger.debug(  
+            "After Update: Updated %d segments, Added %d, Deleted %d",  
+            len(updated_segments), len(new_entries), deleted_count  
+        )  
+  
+
+        return {
+            "updated_segments": LabelVideoSegmentSerializer(
+                updated_segments, many=True
+            ).data,
+            "new_segments": LabelVideoSegmentSerializer(new_entries, many=True).data,
+            "deleted_segments": deleted_count,
+        }

endoreg_db/serializers/meta/__init__.py

@@ -0,0 +1,19 @@
+from .pdf_file_meta_extraction import PDFFileForMetaSerializer
+from .report_meta import (
+    ReportMetaSerializer,
+)
+from .sensitive_meta_detail import SensitiveMetaDetailSerializer
+from .sensitive_meta_update import SensitiveMetaUpdateSerializer
+from .sensitive_meta_verification import SensitiveMetaVerificationSerializer
+from .video_meta import (
+    VideoMetaSerializer,
+)
+
+__all__ = [
+    "PDFFileForMetaSerializer",
+    "ReportMetaSerializer",
+    "SensitiveMetaDetailSerializer",
+    "SensitiveMetaUpdateSerializer",
+    "SensitiveMetaVerificationSerializer",
+    "VideoMetaSerializer",
+]

endoreg_db/serializers/meta/pdf_file_meta_extraction.py

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

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

@@ -0,0 +1,162 @@
+from rest_framework import serializers
+import logging
+
+from ...models import SensitiveMeta
+
+logger = logging.getLogger(__name__)
+
+class SensitiveMetaDetailSerializer(serializers.ModelSerializer):
+    """
+    Serializer for displaying SensitiveMeta details with verification state.
+    Includes all relevant fields for annotation and verification.
+    """
+    
+    # State verification fields
+    is_verified = serializers.SerializerMethodField()
+    dob_verified = serializers.SerializerMethodField()
+    names_verified = serializers.SerializerMethodField()
+    
+    # Related fields for better display
+    center_name = serializers.CharField(source="center.name", read_only=True)
+    patient_gender_name = serializers.CharField(source="patient_gender.name", read_only=True)
+    
+    # Examiner information
+    examiners_display = serializers.SerializerMethodField()
+    
+    # Formatted dates for display
+    patient_dob_display = serializers.SerializerMethodField()
+    examination_date_display = serializers.SerializerMethodField()
+    
+    # Hash displays (last 8 characters for security)
+    patient_hash_display = serializers.SerializerMethodField()
+    examination_hash_display = serializers.SerializerMethodField()
+
+    class Meta:
+        model = SensitiveMeta
+        fields = [
+            'id',
+            'patient_first_name',
+            'patient_last_name', 
+            'patient_dob',
+            'patient_dob_display',
+            'examination_date',
+            'examination_date_display',
+            'center_name',
+            'patient_gender_name',
+            'endoscope_type',
+            'endoscope_sn',
+            'patient_hash_display',
+            'examination_hash_display',
+            'examiners_display',
+            'is_verified',
+            'dob_verified',
+            'names_verified',
+        ]
+        read_only_fields = [
+            'id',
+            'patient_hash_display',
+            'examination_hash_display',
+        ]
+
+    def get_is_verified(self, obj):
+        """
+        Return the overall verification status of the given SensitiveMeta instance.
+        
+        Returns:
+            bool: True if the instance is verified; False if the verification attribute is missing.
+        
+        Raises:
+            Exception: Propagates unexpected exceptions after logging.
+        """
+        try:
+            return obj.is_verified
+        except AttributeError:
+            return False
+        except Exception as e:
+            logger.exception(f"Unexpected error in get_is_verified for SensitiveMeta {getattr(obj, 'pk', None)}: {e}")
+            raise
+
+    def get_dob_verified(self, obj):
+        """
+        Return the date of birth verification status for the given object.
+        
+        Returns:
+            bool: True if the date of birth is verified; otherwise, False if unavailable or on error.
+        """
+        try:
+            return obj.state.dob_verified
+        except Exception:
+            return False
+
+    def get_names_verified(self, obj):
+        """
+        Return whether the patient's names have been verified.
+        
+        Returns:
+            bool: True if the names are verified; False if not verified or if an error occurs.
+        """
+        try:
+            return obj.state.names_verified
+        except Exception:
+            return False
+
+    def get_examiners_display(self, obj):
+        """
+        Return a list of examiner full names for the given SensitiveMeta instance.
+        
+        Returns:
+            list[str]: List of examiner names in "First Last" format, or an empty list if unavailable.
+        """
+        try:
+            if obj.pk:
+                examiners = obj.examiners.all()
+                return [f"{e.first_name} {e.last_name}" for e in examiners]
+            return []
+        except Exception as e:
+            logger.warning(f"Error getting examiners for SensitiveMeta {obj.pk}: {e}")
+            return []
+
+    def get_patient_dob_display(self, obj):
+        """
+        Return the patient's date of birth formatted as "YYYY-MM-DD" for display.
+        
+        Returns:
+            str or None: Formatted date string if available, otherwise None.
+        """
+        if obj.patient_dob:
+            return obj.patient_dob.strftime("%Y-%m-%d")
+        return None
+
+    def get_examination_date_display(self, obj):
+        """
+        Return the examination date formatted as "YYYY-MM-DD" for display.
+        
+        Returns:
+            str or None: Formatted examination date string, or None if not set.
+        """
+        if obj.examination_date:
+            return obj.examination_date.strftime("%Y-%m-%d")
+        return None
+
+    def get_patient_hash_display(self, obj):
+        """
+        Return the last eight characters of the patient's hash, prefixed with ellipsis, or None if not available.
+        
+        Returns:
+            str or None: Truncated patient hash for display, or None if the hash is not set.
+        """
+        if obj.patient_hash:
+            return f"...{obj.patient_hash[-8:]}"
+        return None
+
+    def get_examination_hash_display(self, obj):
+        """
+        Return the last eight characters of the examination hash, prefixed with ellipsis, or None if not available.
+        
+        Returns:
+            str or None: Truncated examination hash for display, or None if the hash is not set.
+        """
+        if obj.examination_hash:
+            return f"...{obj.examination_hash[-8:]}"
+        return None
+

endoreg_db/serializers/meta/sensitive_meta_update.py

@@ -0,0 +1,148 @@
+from rest_framework import serializers
+from django.db import transaction
+import logging
+
+from ...models import SensitiveMeta, Center, Gender
+
+logger = logging.getLogger(__name__)
+
+
+
+class SensitiveMetaUpdateSerializer(serializers.ModelSerializer):
+    """
+    Serializer for updating SensitiveMeta fields including verification state.
+    Handles partial updates and state management.
+    """
+    
+    # Verification state fields
+    dob_verified = serializers.BooleanField(required=False)
+    names_verified = serializers.BooleanField(required=False)
+    
+    # Center can be updated by name
+    center_name = serializers.CharField(write_only=True, required=False)
+    
+    # Gender can be updated by name
+    patient_gender_name = serializers.CharField(write_only=True, required=False)
+
+    class Meta:
+        model = SensitiveMeta
+        fields = [
+            'patient_first_name',
+            'patient_last_name',
+            'patient_dob',
+            'examination_date',
+            'center_name',
+            'patient_gender_name',
+            'endoscope_type',
+            'endoscope_sn',
+            'examiner_first_name',
+            'examiner_last_name',
+            'dob_verified',
+            'names_verified',
+        ]
+
+    def validate_center_name(self, value):
+        """
+        Validates that a center with the given natural key exists.
+        
+        Raises a validation error if the specified center does not exist.
+        """
+        if value:
+            try:
+                Center.objects.get_by_natural_key(value)
+                return value
+            except Center.DoesNotExist:
+                raise serializers.ValidationError(f"Center '{value}' does not exist.")
+        return value
+
+    def validate_patient_gender_name(self, value):
+        """
+        Validates that a gender with the given name exists.
+        
+        Raises a validation error if no matching Gender is found.
+        """
+        if value:
+            try:
+                Gender.objects.get(name=value)
+                return value
+            except Gender.DoesNotExist:
+                raise serializers.ValidationError(f"Gender '{value}' does not exist.")
+        return value
+
+    def validate(self, data):
+        """
+        Validate that patient first and last names, if provided, are not empty strings.
+        
+        Raises a validation error if either `patient_first_name` or `patient_last_name` is present but empty.
+        """
+        # Ensure names are not empty if provided
+        first_name = data.get('patient_first_name')
+        if first_name is not None and not first_name.strip():
+            raise serializers.ValidationError({
+                'patient_first_name': 'First name cannot be empty.'
+            })
+        
+        last_name = data.get('patient_last_name')
+        if last_name is not None and not last_name.strip():
+            raise serializers.ValidationError({
+                'patient_last_name': 'Last name cannot be empty.'
+            })
+
+        return data
+
+    @transaction.atomic
+    def update(self, instance, validated_data):
+        """
+        Updates a SensitiveMeta instance with provided data, including related center, gender, and verification state fields.
+        
+        Handles assignment of related Center and Gender objects by name, updates model fields, and manages verification state flags (`dob_verified`, `names_verified`) in the associated state object if provided.
+        
+        Returns:
+            SensitiveMeta: The updated SensitiveMeta instance.
+        """
+        # Extract verification state data
+        dob_verified = validated_data.pop('dob_verified', None)
+        names_verified = validated_data.pop('names_verified', None)
+        
+        # Extract and handle center update
+        center_name = validated_data.pop('center_name', None)
+        if center_name:
+            try:
+                center = Center.objects.get_by_natural_key(center_name)
+                instance.center = center
+            except Center.DoesNotExist:
+                logger.error(f"Center '{center_name}' not found during update")
+                raise serializers.ValidationError(f"Center '{center_name}' does not exist.")
+        
+        # Extract and handle gender update
+        patient_gender_name = validated_data.pop('patient_gender_name', None)
+        if patient_gender_name:
+            try:
+                gender = Gender.objects.get(name=patient_gender_name)
+                instance.patient_gender = gender
+            except Gender.DoesNotExist:
+                logger.error(f"Gender '{patient_gender_name}' not found during update")
+                raise serializers.ValidationError(f"Gender '{patient_gender_name}' does not exist.")
+
+        # Update regular fields using the model's update_from_dict method
+        if validated_data:
+            instance.update_from_dict(validated_data)
+        
+        # Update verification state if provided
+        if dob_verified is not None or names_verified is not None:
+            # Ensure state exists
+            state = instance.get_or_create_state()
+            
+            if dob_verified is not None:
+                state.dob_verified = dob_verified
+                logger.info(f"Updated DOB verification for SensitiveMeta {instance.pk}: {dob_verified}")
+            
+            if names_verified is not None:
+                state.names_verified = names_verified
+                logger.info(f"Updated names verification for SensitiveMeta {instance.pk}: {names_verified}")
+            
+            state.save()
+
+        return instance
+
+