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

endoreg_db/serializers/label_video_segment/label_video_segment.py

@@ -0,0 +1,344 @@
+from rest_framework import serializers
+from typing import List
+from django.core.exceptions import ObjectDoesNotExist
+from django.conf import settings
+from urllib.parse import urljoin
+from pathlib import Path
+
+from ...models import LabelVideoSegment, VideoFile
+import logging
+from ._lvs_create import (
+    _create,
+    _get_video_file,
+    _get_label,
+    _validate_fps,
+    _calculate_frame_numbers,
+    _get_information_source
+)
+from ._lvs_update import (
+    _update,
+)
+from ._lvs_validate import (
+    _validate,
+    _extract_and_validate_basic_attrs,
+    _process_time_data,
+    _process_frame_data,
+    _validate_time_and_frame_presence,
+    _validate_time_constraints,
+    _validate_frame_constraints
+)
+from endoreg_db.serializers import ImageClassificationAnnotationSerializer
+
+logger = logging.getLogger(__name__)
+
+# add these small helpers (could be private functions in this module)
+def _media_relpath_from_file_path(file_path) -> str:
+    """
+    Return a media-relative path (never an absolute server path).
+    If MEDIA_ROOT is a prefix, strip it; otherwise return the basename.
+    Accepts str or Path-like.
+    """
+    p = Path(str(file_path))
+    media_root = getattr(settings, "MEDIA_ROOT", None)
+    if media_root:
+        try:
+            rel = p.resolve().relative_to(Path(media_root).resolve())
+            return rel.as_posix()
+        except Exception:
+            pass
+    return p.name  # safe fallback
+
+def _media_url_from_file_path(file_path, request=None) -> str:
+    """
+    Build a public URL for the file using MEDIA_URL + relpath.
+    If `request` is provided, return an absolute URL.
+    """
+    base = getattr(settings, "MEDIA_URL", "/media/")
+    if not base.endswith("/"):
+        base += "/"
+    rel = _media_relpath_from_file_path(file_path)
+    url = urljoin(base, rel)
+    if request is not None:
+        try:
+            return request.build_absolute_uri(url)
+        except Exception:
+            pass
+    return url
+
+
+class LabelVideoSegmentSerializer(serializers.ModelSerializer):
+    """Serializer for creating and retrieving LabelVideoSegment instances."""
+    
+    # Additional fields for convenience - matching frontend expectations
+    start_time = serializers.SerializerMethodField()
+    end_time = serializers.SerializerMethodField()
+
+    # Input fields (write_only for creation)
+    video_id = serializers.IntegerField(required=False, help_text="Video file ID")
+    label_id = serializers.IntegerField(required=False, allow_null=True, help_text="Label ID")
+    
+    # Add support for label names (both Label and VideoSegmentationLabel)
+    label_name = serializers.CharField(write_only=True, required=False, allow_null=True, help_text="Label name")
+    label_display = serializers.SerializerMethodField()
+       
+    # Read-only fields for response
+    video_name = serializers.SerializerMethodField(read_only=True)
+    frame_predictions = serializers.SerializerMethodField(read_only=True, help_text="Frame predictions for the video segment")
+    manual_frame_annotations = serializers.SerializerMethodField(read_only=True, help_text="Manual frame annotations for the video segment")
+
+    time_segments = serializers.SerializerMethodField(read_only=True, help_text="Time segments for the video segment")
+
+    create = _create
+    get_video_file = _get_video_file
+    get_label = _get_label
+    validate_fps = _validate_fps
+    calculate_frame_numbers = _calculate_frame_numbers
+    get_information_source = _get_information_source
+
+    update = _update
+
+    validate = _validate
+    extract_and_validate_basic_attrs = _extract_and_validate_basic_attrs
+    process_time_data = _process_time_data
+    process_frame_data = _process_frame_data
+    validate_time_and_frame_presence = _validate_time_and_frame_presence
+    validate_time_constraints = _validate_time_constraints
+    validate_frame_constraints = _validate_frame_constraints
+
+    class Meta:
+        model = LabelVideoSegment
+        fields = [
+            'id',
+            "video_file",
+            'video_name',
+            "video_id",
+            "label",
+            'label_name',
+            "label_id",
+            'start_frame_number',
+            'end_frame_number',
+            'start_time',
+            'end_time',
+            "label_display", 
+            "frame_predictions",
+            "manual_frame_annotations",
+            "time_segments"
+        ]
+        read_only_fields = ['id', 'video_name']
+        extra_kwargs = {
+            'start_frame_number': {'required': False},
+            'end_frame_number': {'required': False},
+            'video_file': {'required': False},
+            'label': {'required': False},
+        }
+    
+
+    def __init__(self, *args, **kwargs):
+        """
+        Initialize the serializer and log the initial input data if available.
+        """
+        super().__init__(*args, **kwargs)
+        if hasattr(self, 'initial_data'):
+            logger.debug(f"Serializer initialized with data: {self.initial_data}")
+
+
+    def get_time_segments(self, obj: LabelVideoSegment) -> List[dict]:
+        frames = obj.frames
+        time_segments = {
+            "segment_id": obj.id,
+            "segment_start": obj.start_frame_number,
+            "segment_end": obj.end_frame_number,
+            "start_time": obj.start_time,
+            "end_time": obj.end_time,
+            "frames": []
+        }
+
+        request = self.context.get("request") if hasattr(self, "context") else None
+
+        for frame in frames:
+            all_classifications = ImageClassificationAnnotationSerializer(
+                frame.image_classification_annotations.all(), many=True
+            ).data
+            predictions = ImageClassificationAnnotationSerializer(frame.predictions, many=True).data
+            manual_annotations = ImageClassificationAnnotationSerializer(
+                frame.manual_annotations, many=True
+            ).data if frame.has_manual_annotations else []
+
+            # 👇 changed here: no absolute server path; give a media-relative path + a URL
+            rel = _media_relpath_from_file_path(frame.file_path)
+            url = _media_url_from_file_path(frame.file_path, request=request)
+
+            frame_data = {
+                "frame_filename": Path(str(frame.file_path)).name,
+                "frame_file_path": rel,            # backwards-compatible, now relative
+                "frame_url": url,                  # new: what the frontend should use
+                "all_classifications": all_classifications,
+                "predictions": predictions,
+                "frame_id": frame.id,
+                "manual_annotations": manual_annotations
+            }
+            time_segments["frames"].append(frame_data)
+
+        return time_segments
+
+    def get_label_name(self, obj):# -> Any | Literal['unknown']:
+        """
+        Return the name of the label associated with the segment, or "unknown" if no label is set.
+        """
+        if obj.label:
+            return obj.label.name
+        return "unknown"
+    
+    def get_manual_frame_annotations(self, obj:LabelVideoSegment):
+        """
+        Return serialized manual frame annotations for the given video segment.
+        
+        Parameters:
+            obj (LabelVideoSegment): The video segment instance whose manual frame annotations are to be serialized.
+        
+        Returns:
+            list: A list of serialized manual frame annotation data.
+        """
+        return ImageClassificationAnnotationSerializer(obj.manual_frame_annotations, many=True).data
+    
+    def get_frame_predictions(self, obj:LabelVideoSegment) -> List[dict]:
+        """
+        Return serialized frame prediction annotations for the given video segment.
+        
+        Parameters:
+            obj (LabelVideoSegment): The video segment instance whose frame predictions are to be serialized.
+        
+        Returns:
+            List[dict]: A list of serialized frame prediction annotation data.
+        """
+        return ImageClassificationAnnotationSerializer(obj.frame_predictions, many=True).data
+    
+    def get_all_annotations(self, obj:LabelVideoSegment):
+        """
+        Retrieve all image classification annotations for every frame in the given video segment.
+        
+        Parameters:
+            obj (LabelVideoSegment): The video segment instance whose frame annotations are to be retrieved.
+        
+        Returns:
+            list: A list of serialized image classification annotations for all frames in the segment.
+        """
+        return ImageClassificationAnnotationSerializer(obj.all_frame_annotations, many=True).data
+
+    def get_label_display(self, obj:LabelVideoSegment):
+        """
+        Return the German translation of the label name for display purposes.
+        
+        If the segment has no label, returns "Unbekannt". If a translation is not available, returns the original label name.
+        """
+        if not obj.label:
+            return "Unbekannt"
+            
+        label_name = obj.label.name
+        #TODO Refactor
+        translations = {
+            'appendix': 'Appendix',
+            'blood': 'Blut',
+            'diverticule': 'Divertikel',
+            'grasper': 'Greifer',
+            'ileocaecalvalve': 'Ileozäkalklappe',
+            'ileum': 'Ileum',
+            'low_quality': 'Niedrige Bildqualität',
+            'nbi': 'Narrow Band Imaging',
+            'needle': 'Nadel',
+            'outside': 'Außerhalb',
+            'polyp': 'Polyp',
+            'snare': 'Snare',
+            'water_jet': 'Wasserstrahl',
+            'wound': 'Wunde'
+        }
+        return translations.get(label_name, label_name)
+    
+    def get_video_name(self, obj):
+        """
+        Return the display name of the video file associated with the segment.
+        
+        If the video file has an `original_file_name`, it is returned; otherwise, a fallback name using the video ID is provided. Returns "Unknown Video" if the video file is inaccessible.
+        """
+        try:
+            video = obj.video_file
+            return getattr(video, 'original_file_name', f'Video {video.id}')
+        except (AttributeError, ObjectDoesNotExist):
+            return 'Unknown Video'
+ 
+    def get_start_time(self, obj:LabelVideoSegment):
+        """
+        Return the start time of the video segment in seconds.
+        """
+        return obj.start_time
+    
+    def get_end_time(self, obj):
+        """
+        Return the end time of the video segment in seconds.
+        """
+        return obj.end_time
+    
+    def is_valid(self, raise_exception=False):
+        """
+        Validates the serializer input data and logs the validation process.
+        
+        Parameters:
+            raise_exception (bool): If True, raises a ValidationError on failure.
+        
+        Returns:
+            bool: True if the data is valid, False otherwise.
+        """
+        logger.debug("Starting validation")
+        result = super().is_valid(raise_exception=raise_exception)
+        if not result:
+            logger.debug(f"Validation errors: {self.errors}")
+        return result
+
+    def to_internal_value(self, data):
+        """
+        Normalizes input data by mapping between `video_id`/`label_id` and `video_file`/`label` keys to ensure consistent internal representation for model creation and validation.
+        
+        This allows the serializer to accept either set of keys and internally synchronize them before further processing.
+        """
+        #TODO @coderabbitai create an issue for @Hamzaukw 
+        # we need to ensure consistent naming across serializers
+        # Currently we use it in various places, but it should be consistent
+        # Either make the usage consistent or create another serializer that handles this
+        # Map video_file → video_id and label → label_id
+        if 'video_file' in data:
+            data['video_id'] = data['video_file']
+        if 'label' in data:
+            data['label_id'] = data['label']
+        # Map video_id → video_file and label_id → label
+        if 'video_id' in data:
+            data['video_file'] = data['video_id']
+        if 'label_id' in data:
+            data['label'] = data['label_id']
+        return super().to_internal_value(data)
+    
+    def to_representation(self, instance):
+        """
+        Return a JSON-compatible representation of a label video segment with calculated start and end times in seconds, label name, and explicit video and label IDs.
+        
+        Raises:
+            ValueError: If the segment is not associated with a video file.
+            TypeError: If the associated video file is not a VideoFile instance.
+        """
+        data = super().to_representation(instance)
+        video_file = instance.video_file
+        if video_file is None:
+            raise ValueError("Video file must be associated with the segment")
+        if not isinstance(video_file, VideoFile):
+            raise TypeError("Expected video_file to be an instance of VideoFile")
+        # Add calculated time fields for frontend compatibility
+        data['start_time'] = video_file.frame_number_to_s(instance.start_frame_number)
+        data['end_time'] = video_file.frame_number_to_s(instance.end_frame_number)
+        # Ensure label_name is always present in response
+        if instance.label:
+            data['label_name'] = instance.label.name
+        else:
+            data['label_name'] = None
+        # Explicitly add video_id and label_id to the output for frontend convenience
+        data['video_id'] = instance.video_file.id if instance.video_file else None
+        data['label_id'] = instance.label.id if instance.label else None
+        return data

endoreg_db/serializers/label_video_segment/label_video_segment_annotation.py

@@ -0,0 +1,99 @@
+from rest_framework import serializers
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class LabelVideoSegmentAnnotationSerializer(serializers.Serializer):
+    """
+    Serializer for annotation data.
+    Handles segment annotations with metadata including segmentId.
+    """
+    id = serializers.IntegerField(read_only=True)
+    videoId = serializers.IntegerField(required=True)
+    startTime = serializers.FloatField(required=False)
+    endTime = serializers.FloatField(required=False)
+    type = serializers.CharField(max_length=50, required=True)
+    text = serializers.CharField(max_length=1000, required=False, allow_blank=True)
+    tags = serializers.ListField(
+        child=serializers.CharField(max_length=100),
+        required=False,
+        default=list
+    )
+    userId = serializers.CharField(max_length=100, required=False)
+    isPublic = serializers.BooleanField(default=False)
+    confidence = serializers.FloatField(required=False, min_value=0.0, max_value=1.0)
+    metadata = serializers.DictField(required=False, default=dict)
+    
+    def validate(self, data):
+        """
+        Validates annotation data, enforcing required fields and value constraints for segment annotations.
+        
+        For annotations of type 'segment', ensures both `startTime` and `endTime` are present and that `startTime` is less than `endTime`. If `metadata.segmentId` is provided, verifies it is a valid integer.
+        
+        Raises:
+            serializers.ValidationError: If validation fails.
+            
+        Returns:
+            dict: The validated annotation data.
+        """
+        annotation_type = data.get('type')
+        
+        if annotation_type == 'segment':
+            if 'startTime' not in data or 'endTime' not in data:
+                raise serializers.ValidationError(
+                    "Segment annotations must include startTime and endTime"
+                )
+            
+            start_time = data.get('startTime')
+            end_time = data.get('endTime')
+            
+            if start_time >= end_time:
+                raise serializers.ValidationError(
+                    "startTime must be less than endTime"
+                )
+                
+            # Validate metadata contains segmentId if provided
+            metadata = data.get('metadata', {})
+            segment_id = metadata.get('segmentId')
+            if segment_id is not None:
+                try:
+                    int(segment_id)
+                except (ValueError, TypeError):
+                    raise serializers.ValidationError(
+                        "metadata.segmentId must be a valid integer"
+                    )
+        
+        return data
+    
+    #@maxhild we need to verify if this is the right place for these methods, if so we should implement them here
+    def create(self, validated_data):
+        """
+        Assigns a unique ID to the annotation data and returns the updated data dictionary.
+        
+        In this simulated implementation, the method mimics creating a new annotation by incrementing an internal counter for the ID. No data is persisted to a database or external storage.
+         
+        Returns:
+            dict: The annotation data with an assigned unique ID.
+        """
+        # Simulate creating an annotation with an ID
+        validated_data['id'] = getattr(self, '_next_id', 1)
+        self._next_id = validated_data['id'] + 1
+        return validated_data
+    
+    def update(self, instance, validated_data):
+        """
+        Update annotation data structure.
+        """
+        for attr, value in validated_data.items():
+            instance[attr] = value
+        return instance
+    
+    def save(self, **kwargs):
+        """
+        Save the annotation.
+        """
+        if self.instance:
+            return self.update(self.instance, self.validated_data)
+        else:
+            return self.create(self.validated_data)

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",
+]