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

endoreg_db/serializers/label_video_segment/_lvs_update.py

@@ -1,138 +0,0 @@
-from typing import TYPE_CHECKING, Dict, Any, Optional
-from django.core.exceptions import ObjectDoesNotExist
-from rest_framework import serializers
-from endoreg_db.models import (
-    Label,
-    VideoFile,
-    LabelVideoSegment
-)
-
-import logging
-logger = logging.getLogger(__name__)
-
-if TYPE_CHECKING:
-    from endoreg_db.serializers import LabelVideoSegmentSerializer
-
-
-def _validate_fps(video: "VideoFile"):
-    """Raises a ValidationError if the video's FPS is invalid."""
-    fps = video.get_fps()
-    if not fps or fps <= 0:
-        raise serializers.ValidationError("The video must have a valid FPS to convert times to frames.")
-    return fps
-
-def _convert_time_to_frame(time_value: float, fps: float) -> int:
-    """Converts a time value in seconds to a frame number."""
-    return int(time_value * fps)
-
-def _update_frames_from_data(instance: "LabelVideoSegment", validated_data: Dict[str, Any], fps: Optional[float]):
-    """Updates start and end frames from either time or frame data."""
-    if 'start_time' in validated_data:
-        if fps is None:
-            fps = _validate_fps(instance.video)
-        instance.start_frame_number = _convert_time_to_frame(validated_data['start_time'], fps)
-    elif 'start_frame' in validated_data:
-        instance.start_frame_number = validated_data['start_frame']
-
-    if 'end_time' in validated_data:
-        if fps is None:
-            fps = _validate_fps(instance.video)
-        instance.end_frame_number = _convert_time_to_frame(validated_data['end_time'], fps)
-    elif 'end_frame' in validated_data:
-        instance.end_frame_number = validated_data['end_frame']
-
-def _update(instance: "LabelVideoSegment", validated_data: Dict[str, Any]) -> "LabelVideoSegment":
-    """
-    Handles the update logic for a LabelVideoSegment instance.
-    This function is designed to be used within a serializer's update method.
-    """
-    video: Optional["VideoFile"] = validated_data.get('video')
-    fps = None
-
-    if video and video != instance.video:
-        instance.video = video
-        fps = _validate_fps(video)  # Validate FPS for the new video
-
-    if 'label' in validated_data:
-        instance.label = validated_data['label']
-
-    _update_frames_from_data(instance, validated_data, fps)
-
-    # Final validation of frame numbers
-    if instance.start_frame_number >= instance.end_frame_number:
-        raise serializers.ValidationError("start_frame must be less than end_frame.")
-    
-    if instance.video and instance.end_frame_number > instance.video.frame_count:
-        raise serializers.ValidationError("end_frame cannot exceed the total frames of the video.")
-
-    instance.save()
-    return instance
-
-def _update(self:"LabelVideoSegmentSerializer", instance, validated_data):
-    """
-    Update a LabelVideoSegment instance with new validated data.
-    
-    This method updates the associated video file, label (by ID or name), and segment boundaries (start and end times converted to frame numbers based on the video's FPS). If the referenced video or label does not exist, or if any error occurs during the update, a validation error is raised.
-    
-    Returns:
-        The updated LabelVideoSegment instance.
-    """
-    try:
-        # Handle time-based updates
-        start_time = validated_data.pop('start_time', None)
-        end_time = validated_data.pop('end_time', None)
-        video_id = validated_data.pop('video_id', None)
-        label_id = validated_data.pop('label_id', None)
-        label_name = validated_data.pop('label_name', None)
-        
-        # Update video if provided
-        if video_id and (not instance.video_file or video_id != instance.video_file.id):
-            try:
-                instance.video_file = VideoFile.objects.get(id=video_id)
-            except ObjectDoesNotExist as exc:
-                raise serializers.ValidationError(f"VideoFile with id {video_id} does not exist") from exc
-        
-        # Update label if provided
-        if label_id is not None:
-            if label_id:
-                try:
-                    instance.label = Label.objects.get(id=label_id)
-                except ObjectDoesNotExist as exc:
-                    raise serializers.ValidationError(f"Label with id {label_id} does not exist") from exc
-            else:
-                instance.label = None
-        elif label_name is not None:
-            if label_name:
-                instance.label = self.get_or_create_label_from_name(label_name)
-            else:
-                instance.label = None
-        
-        def _get_valid_fps(video_file):
-            """
-            Extract and validate the frames-per-second (FPS) value from a video file object.
-            
-            Returns:
-                float: The FPS value as a positive float. Defaults to 30.0 if missing, invalid, or non-positive.
-            """
-
-        # Convert time to frame numbers if provided
-        if start_time is not None:
-            fps = _validate_fps(instance.video_file)
-            instance.start_frame_number = _convert_time_to_frame(start_time, fps)
-        
-        if end_time is not None:
-            fps = _validate_fps(instance.video_file)
-            instance.end_frame_number = _convert_time_to_frame(end_time, fps)
-        
-        # Update other fields
-        for attr, value in validated_data.items():
-            setattr(instance, attr, value)
-        
-        instance.save()
-        logger.info("Updated video segment: %s", instance.pk)
-        return instance
-        
-    except Exception as e:
-        logger.error("Error updating video segment %s: %s", instance.pk, str(e))
-        raise serializers.ValidationError(f"Failed to update segment: {str(e)}")
-

endoreg_db/serializers/label_video_segment/_lvs_validate.py

@@ -1,149 +0,0 @@
-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_annotation.py

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

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