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

endoreg_db/serializers/label_video_segment/_lvs_validate.py

@@ -0,0 +1,149 @@
+import logging
+from rest_framework import serializers
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from endoreg_db.serializers import LabelVideoSegmentSerializer
+
+logger = logging.getLogger(__name__)
+
+def _validate(self:"LabelVideoSegmentSerializer", attrs):
+    """
+    Validate video segment data, ensuring the presence and logical consistency of either time-based or frame-based segment information.
+    
+    Raises:
+        ValidationError: If neither valid time nor frame data is provided, or if time/frame constraints are violated.
+    
+    Returns:
+        dict: The validated attributes for the video segment.
+    """
+    logger.debug("Validation started")
+    video_id, label_id = self.extract_and_validate_basic_attrs(attrs)
+    instance = getattr(self, 'instance', None)
+    start_time, end_time = self.process_time_data(attrs, instance)
+    start_frame_number, end_frame_number = self.process_frame_data(attrs, instance)
+    has_time_data, has_frame_data = self.validate_time_and_frame_presence(start_time, end_time, start_frame_number, end_frame_number)
+    label_id = attrs.get('label_id')
+    label_name = attrs.get('label_name')
+    if not label_id and not label_name:
+        logger.info("Creating segment without label")
+    if has_time_data:
+        self.validate_time_constraints(start_time, end_time)
+    if has_frame_data:
+        self.validate_frame_constraints(start_frame_number, end_frame_number)
+    logger.debug(f"Attributes after validation: {attrs}")
+    return attrs
+
+def _extract_and_validate_basic_attrs(self:"LabelVideoSegmentSerializer", attrs):
+    """
+    Extract and return the video and label identifiers from the provided attributes or initial data.
+    
+    Returns:
+        Tuple containing the resolved video ID and label ID.
+    """
+    video_id = attrs.get('video_id') or self.initial_data.get('video_id') or self.initial_data.get('video_file')
+    label_id = attrs.get('label_id') or self.initial_data.get('label_id') or self.initial_data.get('label')
+    logger.debug(f"Validating video segment: video_id={video_id}, label_id={label_id}, attrs={{k: v for k, v in attrs.items() if k not in ['video_file', 'label']}}")
+    return video_id, label_id
+
+def _process_time_data(self:"LabelVideoSegmentSerializer", attrs, instance):
+    """
+    Extract and convert start and end time values from input data, ensuring they are floats or None.
+    
+    Parameters:
+        attrs (dict): Input attributes containing potential time values.
+        instance: Existing object instance to use as a fallback for time values.
+    
+    Returns:
+        tuple: A pair (start_time, end_time), each as a float or None if missing or invalid.
+    """
+    start_time = attrs.get('start_time', None)
+    end_time = attrs.get('end_time', None)
+    if instance is not None:
+        if start_time is None:
+            start_time = getattr(instance, 'start_time', None)
+        if end_time is None:
+            end_time = getattr(instance, 'end_time', None)
+    # Always convert start_time/end_time to float if present
+    if 'start_time' in self.initial_data:
+        try:
+            attrs['start_time'] = float(self.initial_data['start_time'])
+        except (TypeError, ValueError):
+            attrs['start_time'] = None
+        start_time = attrs['start_time']
+    elif start_time is not None:
+        try:
+            start_time = float(start_time)
+            attrs['start_time'] = start_time
+        except (TypeError, ValueError):
+            start_time = None
+            attrs['start_time'] = None
+    if 'end_time' in self.initial_data:
+        try:
+            attrs['end_time'] = float(self.initial_data['end_time'])
+        except (TypeError, ValueError):
+            attrs['end_time'] = None
+        end_time = attrs['end_time']
+    elif end_time is not None:
+        try:
+            end_time = float(end_time)
+            attrs['end_time'] = end_time
+        except (TypeError, ValueError):
+            end_time = None
+            attrs['end_time'] = None
+    return start_time, end_time
+
+def _process_frame_data(self:"LabelVideoSegmentSerializer", attrs, instance):
+    """
+    Retrieve start and end frame numbers from input attributes or an existing instance.
+    
+    Returns:
+        tuple: A pair containing the start and end frame numbers, or None if not available.
+    """
+    start_frame_number = attrs.get('start_frame_number')
+    end_frame_number = attrs.get('end_frame_number')
+    if instance is not None:
+        if start_frame_number is None:
+            start_frame_number = getattr(instance, 'start_frame_number', None)
+        if end_frame_number is None:
+            end_frame_number = getattr(instance, 'end_frame_number', None)
+    return start_frame_number, end_frame_number
+
+def _validate_time_and_frame_presence(self:"LabelVideoSegmentSerializer", start_time, end_time, start_frame_number, end_frame_number):
+    """
+    Check that either both time values or both frame number values are provided for a video segment.
+    
+    Raises a ValidationError if neither a complete time range nor a complete frame range is present.
+    
+    Returns:
+        has_time_data (bool): True if both start_time and end_time are provided.
+        has_frame_data (bool): True if both start_frame_number and end_frame_number are provided.
+    """
+    has_time_data = start_time is not None and end_time is not None
+    has_frame_data = start_frame_number is not None and end_frame_number is not None
+    if not has_time_data and not has_frame_data:
+        raise serializers.ValidationError(
+            "Either start_time/end_time or start_frame_number/end_frame_number must be provided"
+        )
+    return has_time_data, has_frame_data
+
+def _validate_time_constraints(self:"LabelVideoSegmentSerializer", start_time, end_time):
+    """
+    Validate that the start and end times for a video segment are logically consistent.
+    
+    Raises a ValidationError if start_time is negative or if end_time is not strictly greater than start_time.
+    """
+    if start_time < 0:
+        raise serializers.ValidationError("start_time must be non-negative")
+    if end_time <= start_time:
+        raise serializers.ValidationError("end_time must be greater than start_time")
+
+def _validate_frame_constraints(self:"LabelVideoSegmentSerializer", start_frame_number, end_frame_number):
+    """
+    Validate that frame number constraints are satisfied for a video segment.
+    
+    Raises a ValidationError if `start_frame_number` is negative or if `end_frame_number` is not greater than `start_frame_number`.
+    """
+    if start_frame_number < 0:
+        raise serializers.ValidationError("start_frame_number must be non-negative")
+    if end_frame_number <= start_frame_number:
+        raise serializers.ValidationError("end_frame_number must be greater than start_frame_number")

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)