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

endoreg_db/views/label_video_segment/label_video_segment_by_label.py

@@ -1,174 +0,0 @@
-from endoreg_db.models import Label, LabelVideoSegment, VideoFile
-from django.shortcuts import get_object_or_404
-from django.http import Http404
-from rest_framework import status
-from rest_framework.decorators import api_view, permission_classes
-from rest_framework.response import Response
-
-from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
-
-import logging
-
-logger = logging.getLogger(__name__)
-
-DEFAULT_FPS = 50 #TODO move to settings or config
-
-@api_view(['GET'])
-@permission_classes(DEBUG_PERMISSIONS) #TODO: Uncomment this line if authentication is set up
-def video_segments_by_label_id_view(request, video_id, label_id):
-    """
-    Retrieves all labeled segments for a given video and label by their IDs.
-
-    Returns a list of time segments for the specified video and label, including start and end frames and their corresponding times in seconds. If no segments exist, returns an empty list. Responds with 404 if the video or label is not found.
-    """
-    try:
-        video = get_object_or_404(VideoFile, id=video_id)
-        label = get_object_or_404(Label, id=label_id)
-
-        # Get all segments for this video and label combination
-        segments = LabelVideoSegment.objects.filter(
-            video_file=video,
-            label=label
-        ).order_by('start_frame_number')
-
-        # Build response in the expected format
-        if segments.exists():
-            # Get video properties for time calculation
-            fps = video.get_fps() or DEFAULT_FPS  # Use module-level constant
-
-            time_segments = []
-            for segment in segments:
-                # Convert frame numbers to time
-                start_time = segment.start_frame_number / fps
-                end_time = segment.end_frame_number / fps
-
-                time_segments.append({
-                    'segment_start': segment.start_frame_number,
-                    'segment_end': segment.end_frame_number,
-                    'start_time': start_time,
-                    'end_time': end_time,
-                    'frames': {}  # Empty for now, can be populated if needed
-                })
-
-            response_data = {
-                'label': label.name,
-                'label_id': label.id,
-                'time_segments': time_segments
-            }
-        else:
-            # Return empty response if no segments found
-            response_data = {
-                'label': label.name,
-                'label_id': label.id,
-                'time_segments': []
-            }
-
-        return Response(response_data)
-    except Http404 as e:
-        return Response({'error': str(e)}, status=status.HTTP_404_NOT_FOUND)
-    except VideoFile.DoesNotExist:
-        return Response(
-            {'error': f'Video with id {video_id} not found'},
-            status=status.HTTP_404_NOT_FOUND
-        )
-    except Label.DoesNotExist:
-        return Response(
-            {'error': f'Label with id {label_id} not found'},
-            status=status.HTTP_404_NOT_FOUND
-        )
-    except Exception as e:
-        logger.error(f"Error fetching segments for video {video_id} and label {label_id}: {str(e)}")
-        return Response(
-            {'error': f'Internal server error: {str(e)}'},
-            status=status.HTTP_500_INTERNAL_SERVER_ERROR
-        )
-
-
-@api_view(['GET'])
-@permission_classes(DEBUG_PERMISSIONS) #TODO: Uncomment this line if authentication is set up
-def video_segments_by_label_name_view(request, video_id, label_name):
-    """
-    Retrieves labeled video segments for a given video and label name.
-
-    Handles cases where multiple labels share the same name by returning a conflict response with details of all matching labels and a suggestion to use the label ID endpoint. If a unique label is found, returns a list of segments for the specified video and label, including frame and time information. Returns appropriate error responses if the video or label is not found, or if an internal error occurs.
-    """
-    try:
-        video = get_object_or_404(VideoFile, id=video_id)
-
-        # Find all labels with this name
-        labels_with_name = Label.objects.filter(name=label_name)
-
-        if not labels_with_name.exists():
-            return Response(
-                {'error': f'No labels found with name "{label_name}"'},
-                status=status.HTTP_404_NOT_FOUND
-            )
-
-        if labels_with_name.count() > 1:
-            # Multiple labels with same name - log warning and return info about all
-            logger.warning(f"Multiple labels found with name '{label_name}': {[l.id for l in labels_with_name]}")
-
-            return Response({
-                'error': f'Multiple labels found with name "{label_name}"',
-                'suggestion': 'Use the label-id endpoint instead for unambiguous results',
-                'available_labels': [
-                    {'id': label.id, 'name': label.name, 'description': label.description}
-                    for label in labels_with_name
-                ]
-            }, status=status.HTTP_409_CONFLICT)
-
-        # Single label found - proceed normally
-        label = labels_with_name.first()
-
-        # Get all segments for this video and label combination
-        segments = LabelVideoSegment.objects.filter(
-            video_file=video,
-            label=label
-        ).order_by('start_frame_number')
-
-        # Build response in the expected format
-        if segments.exists():
-            # Get video properties for time calculation
-            fps = video.get_fps() or DEFAULT_FPS  # Use module-level constant
-
-            time_segments = []
-            for segment in segments:
-                # Convert frame numbers to time
-                start_time = segment.start_frame_number / fps
-                end_time = segment.end_frame_number / fps
-
-                time_segments.append({
-                    'segment_start': segment.start_frame_number,
-                    'segment_end': segment.end_frame_number,
-                    'start_time': start_time,
-                    'end_time': end_time,
-                    'frames': {}  # Empty for now, can be populated if needed
-                })
-
-            response_data = {
-                'label': label.name,
-                'label_id': label.id,
-                'time_segments': time_segments
-            }
-        else:
-            # Return empty response if no segments found
-            response_data = {
-                'label': label.name,
-                'label_id': label.id,
-                'time_segments': []
-            }
-
-        return Response(response_data)
-    except Http404 as e:
-        return Response({'error': str(e)}, status=status.HTTP_404_NOT_FOUND)
-    except VideoFile.DoesNotExist:
-        return Response(
-            {'error': f'Video with id {video_id} not found'},
-            status=status.HTTP_404_NOT_FOUND
-        )
-    except Exception as e:
-        logger.error(f"Error fetching segments for video {video_id} and label '{label_name}': {str(e)}")
-        return Response(
-            {'error': f'Internal server error: {str(e)}'},
-            status=status.HTTP_500_INTERNAL_SERVER_ERROR
-        )

endoreg_db/views/label_video_segment/label_video_segment_detail.py

@@ -1,73 +0,0 @@
-from endoreg_db.models import LabelVideoSegment
-from endoreg_db.serializers.label_video_segment.label_video_segment import LabelVideoSegmentSerializer
-from django.db import transaction
-from django.shortcuts import get_object_or_404
-from rest_framework import status
-from rest_framework.decorators import api_view, permission_classes
-from rest_framework.response import Response
-
-from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
-
-import logging
-logger = logging.getLogger(__name__)
-
-@api_view(['GET', 'PUT', 'DELETE', 'PATCH'])
-@permission_classes(DEBUG_PERMISSIONS)
-def video_segment_detail_view(request, segment_id):
-    """
-    Handles retrieval, update, and deletion of a single labeled video segment.
-
-    Supports:
-    - GET: Returns details of the specified video segment.
-    - PUT: Partially updates the segment with validated data.
-    - DELETE: Removes the segment from the database.
-
-    Returns appropriate HTTP status codes and error messages for invalid data or exceptions.
-    """
-    segment = get_object_or_404(LabelVideoSegment, id=segment_id)
-
-    if request.method == 'GET':
-        serializer = LabelVideoSegmentSerializer(segment)
-        return Response(serializer.data)
-
-    elif request.method in ('PUT', 'PATCH'):
-        logger.info(f"Updating video segment {segment_id} with data: {request.data}")
-
-        partial = request.method == 'PATCH'  # Allow partial updates with PATCH
-
-        with transaction.atomic():
-            serializer = LabelVideoSegmentSerializer(segment, data=request.data, partial=partial)
-            if serializer.is_valid():
-                try:
-                    segment = serializer.save()
-                    logger.info(f"Successfully updated video segment {segment_id}")
-                    return Response(LabelVideoSegmentSerializer(segment).data)
-                except Exception as e:
-                    logger.error(f"Error updating video segment {segment_id}: {str(e)}")
-                    return Response(
-                        {'error': f'Failed to update segment: {str(e)}'},
-                        status=status.HTTP_500_INTERNAL_SERVER_ERROR
-                    )
-            else:
-                logger.warning(f"Invalid data for video segment update: {serializer.errors}")
-                return Response(
-                    {'error': 'Invalid data', 'details': serializer.errors},
-                    status=status.HTTP_400_BAD_REQUEST
-                )
-
-    elif request.method == 'DELETE':
-        logger.info(f"Deleting video segment {segment_id}")
-        try:
-            with transaction.atomic():
-                segment.delete()
-                logger.info(f"Successfully deleted video segment {segment_id}")
-                return Response(
-                    {'message': f'Segment {segment_id} deleted successfully'},
-                    status=status.HTTP_204_NO_CONTENT
-                )
-        except Exception as e:
-            logger.error(f"Error deleting video segment {segment_id}: {str(e)}")
-            return Response(
-                {'error': f'Failed to delete segment: {str(e)}'},
-                status=status.HTTP_500_INTERNAL_SERVER_ERROR
-            )

endoreg_db/views/label_video_segment/update_lvs_from_annotation.py

@@ -1,46 +0,0 @@
-from endoreg_db.models import LabelVideoSegment, InformationSource
-from endoreg_db.serializers import LabelVideoSegmentSerializer
-from rest_framework import status
-from rest_framework.decorators import api_view, permission_classes
-from rest_framework.permissions import IsAuthenticated
-from rest_framework.response import Response
-import logging
-
-logger = logging.getLogger(__name__)
-
-@api_view(['PATCH'])
-@permission_classes([IsAuthenticated])
-def update_label_video_segment(request, annotation_id) -> Response:
-    """
-    Update an existing LabelVideoSegment, treating it as a manual annotation.
-    """
-    logger.info(f"Updating LabelVideoSegment {annotation_id} with data: {request.data}")
-
-    try:
-        segment = LabelVideoSegment.objects.get(id=annotation_id)
-    except LabelVideoSegment.DoesNotExist:
-        logger.error(f"LabelVideoSegment {annotation_id} not found")
-        return Response(
-            {'error': 'Segment not found'},
-            status=status.HTTP_404_NOT_FOUND
-        )
-
-    data = request.data
-    updated = False
-
-    if 'start_frame' in data:
-        segment.start_frame_number = data['start_frame']
-        updated = True
-    
-    if 'end_frame' in data:
-        segment.end_frame_number = data['end_frame']
-        updated = True
-
-    if updated:
-        # Ensure the source is correct for a manual annotation
-        manual_source, _ = InformationSource.objects.get_or_create(name="manual_annotation")
-        segment.source = manual_source
-        segment.save()
-
-    serializer = LabelVideoSegmentSerializer(segment)
-    return Response(serializer.data)

endoreg_db/views/label_video_segment/validate.py

@@ -1,226 +0,0 @@
-from rest_framework import status
-from rest_framework.response import Response
-from rest_framework.views import APIView
-from django.db import transaction
-from endoreg_db.models import LabelVideoSegment, VideoFile
-from endoreg_db.utils.permissions import DEBUG_PERMISSIONS
-
-
-class LabelVideoSegmentValidateView(APIView):
-    """
-    POST /api/label-video-segment/<int:segment_id>/validate/
-    
-    Validiert ein einzelnes LabelVideoSegment und markiert es als verifiziert.
-    Dies wird verwendet, um vom Benutzer überprüfte Segment-Annotationen zu bestätigen.
-    
-    Body (optional):
-    {
-      "is_validated": true,  // optional, default true
-      "notes": "..."         // optional, Validierungsnotizen
-    }
-    """
-    permission_classes = DEBUG_PERMISSIONS
-
-    @transaction.atomic
-    def post(self, request, segment_id: int):
-        try:
-            # Segment abrufen
-            segment = LabelVideoSegment.objects.select_related('state', 'video_file', 'label').get(pk=segment_id)
-            
-            # Validierungsstatus aus Request (default: True)
-            is_validated = request.data.get('is_validated', True)
-            notes = request.data.get('notes', '')
-            
-            # State-Objekt abrufen oder erstellen
-            if not hasattr(segment, 'state') or segment.state is None:
-                # State muss existieren - wenn nicht, könnte ein Model-Problem vorliegen
-                return Response({
-                    "error": "Segment has no state object. Cannot validate."
-                }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-            
-            # State aktualisieren
-            segment.state.is_validated = is_validated
-            if notes:
-                # Falls ein notes-Feld existiert
-                if hasattr(segment.state, 'validation_notes'):
-                    segment.state.validation_notes = notes
-            segment.state.save()
-            
-            return Response({
-                "message": f"Segment {segment_id} validation status updated.",
-                "segment_id": segment_id,
-                "is_validated": is_validated,
-                "label": segment.label.name if segment.label else None,
-                "video_id": segment.video_file.id if segment.video_file else None,
-                "start_frame": segment.start_frame_number,
-                "end_frame": segment.end_frame_number
-            }, status=status.HTTP_200_OK)
-            
-        except LabelVideoSegment.DoesNotExist:
-            return Response({
-                "error": f"Segment {segment_id} not found."
-            }, status=status.HTTP_404_NOT_FOUND)
-        except Exception as e:
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.error(f"Error validating segment {segment_id}: {e}")
-            return Response({
-                "error": f"Validation failed: {str(e)}"
-            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-class BulkSegmentValidateView(APIView):
-    """
-    POST /api/label-video-segments/validate-bulk/
-    
-    Validiert mehrere LabelVideoSegments gleichzeitig.
-    Nützlich für Batch-Validierung nach Review.
-    
-    Body:
-    {
-      "segment_ids": [1, 2, 3, ...],
-      "is_validated": true,  // optional, default true
-      "notes": "..."         // optional, gilt für alle Segmente
-    }
-    """
-    permission_classes = DEBUG_PERMISSIONS
-
-    @transaction.atomic
-    def post(self, request):
-        segment_ids = request.data.get('segment_ids', [])
-        is_validated = request.data.get('is_validated', True)
-        notes = request.data.get('notes', '')
-        
-        if not segment_ids:
-            return Response({
-                "error": "segment_ids is required"
-            }, status=status.HTTP_400_BAD_REQUEST)
-        
-        try:
-            # Alle Segmente abrufen
-            segments = LabelVideoSegment.objects.filter(pk__in=segment_ids).select_related('state')
-            
-            if not segments.exists():
-                return Response({
-                    "error": "No segments found with provided IDs"
-                }, status=status.HTTP_404_NOT_FOUND)
-            
-            updated_count = 0
-            failed_ids = []
-            
-            for segment in segments:
-                try:
-                    if segment.state:
-                        segment.state.is_validated = is_validated
-                        if notes and hasattr(segment.state, 'validation_notes'):
-                            segment.state.validation_notes = notes
-                        segment.state.save()
-                        updated_count += 1
-                    else:
-                        failed_ids.append(segment.id)
-                except Exception as e:
-                    import logging
-                    logger = logging.getLogger(__name__)
-                    logger.error(f"Error validating segment {segment.id}: {e}")
-                    failed_ids.append(segment.id)
-            
-            response_data = {
-                "message": f"Bulk validation completed. {updated_count} segments updated.",
-                "updated_count": updated_count,
-                "requested_count": len(segment_ids),
-                "is_validated": is_validated
-            }
-            
-            if failed_ids:
-                response_data["failed_ids"] = failed_ids
-                response_data["warning"] = f"{len(failed_ids)} segments could not be validated"
-            
-            return Response(response_data, status=status.HTTP_200_OK)
-            
-        except Exception as e:
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.error(f"Error in bulk validation: {e}")
-            return Response({
-                "error": f"Bulk validation failed: {str(e)}"
-            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-
-
-class VideoSegmentValidationCompleteView(APIView):
-    """
-    POST /api/videos/<int:video_id>/segments/validate-complete/
-    
-    Markiert alle Segmente eines Videos als validiert.
-    Nützlich nach vollständiger Review eines Videos.
-    
-    Body (optional):
-    {
-      "label_name": "...",   // optional, nur Segmente mit diesem Label validieren
-      "notes": "..."         // optional
-    }
-    """
-    permission_classes = DEBUG_PERMISSIONS
-
-    @transaction.atomic
-    def post(self, request, video_id: int):
-        try:
-            # Video abrufen
-            video = VideoFile.objects.get(pk=video_id)
-            
-            label_name = request.data.get('label_name')
-            notes = request.data.get('notes', '')
-            
-            # Segmente filtern
-            segments_query = LabelVideoSegment.objects.filter(video_file=video).select_related('state', 'label')
-            
-            if label_name:
-                segments_query = segments_query.filter(label__name=label_name)
-            
-            segments = segments_query.all()
-            
-            if not segments.exists():
-                return Response({
-                    "message": "No segments found to validate",
-                    "video_id": video_id,
-                    "updated_count": 0
-                }, status=status.HTTP_200_OK)
-            
-            updated_count = 0
-            failed_count = 0
-            
-            for segment in segments:
-                try:
-                    if segment.state:
-                        segment.state.is_validated = True
-                        if notes and hasattr(segment.state, 'validation_notes'):
-                            segment.state.validation_notes = notes
-                        segment.state.save()
-                        updated_count += 1
-                    else:
-                        failed_count += 1
-                except Exception as e:
-                    import logging
-                    logger = logging.getLogger(__name__)
-                    logger.error(f"Error validating segment {segment.id}: {e}")
-                    failed_count += 1
-            
-            return Response({
-                "message": f"Video segment validation completed for video {video_id}",
-                "video_id": video_id,
-                "total_segments": len(segments),
-                "updated_count": updated_count,
-                "failed_count": failed_count,
-                "label_filter": label_name
-            }, status=status.HTTP_200_OK)
-            
-        except VideoFile.DoesNotExist:
-            return Response({
-                "error": f"Video {video_id} not found"
-            }, status=status.HTTP_404_NOT_FOUND)
-        except Exception as e:
-            import logging
-            logger = logging.getLogger(__name__)
-            logger.error(f"Error completing validation for video {video_id}: {e}")
-            return Response({
-                "error": f"Validation completion failed: {str(e)}"
-            }, status=status.HTTP_500_INTERNAL_SERVER_ERROR)

endoreg_db/views/media/segments.py

@@ -1,71 +0,0 @@
-"""
-Modern Media Framework - Video Segment API Views
-October 14, 2025 - Migration to unified /api/media/videos/<pk>/segments/ pattern
-
-This module provides modern framework views for video segment management,
-wrapping legacy segment views with pk-based parameter handling.
-"""
-from endoreg_db.models import Label, LabelVideoSegment, VideoFile
-from endoreg_db.serializers.label_video_segment.label_video_segment import LabelVideoSegmentSerializer
-
-from django.db import transaction
-from rest_framework import status
-from rest_framework.decorators import api_view, permission_classes
-from rest_framework.response import Response
-
-from endoreg_db.utils.permissions import EnvironmentAwarePermission
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-@api_view(['GET'])
-@permission_classes([EnvironmentAwarePermission])
-def video_segments_by_pk(request, pk):
-    """
-    Modern media framework endpoint for retrieving video segments.
-    
-    GET /api/media/videos/<int:pk>/segments/?label=<label_name>
-    
-    Returns all segments for a video, optionally filtered by label name.
-    This is the modern replacement for /api/video/<id>/segments/
-    
-    Query Parameters:
-        label (str, optional): Filter segments by label name (e.g., 'outside')
-    
-    Returns:
-        200: List of video segments
-        404: Video not found
-    """
-    try:
-        video = VideoFile.objects.get(id=pk)
-    except VideoFile.DoesNotExist:
-        logger.warning(f"Video with pk {pk} not found")
-        return Response(
-            {'error': f'Video with id {pk} not found'},
-            status=status.HTTP_404_NOT_FOUND
-        )
-    
-    # Start with all segments for this video
-    queryset = LabelVideoSegment.objects.filter(video_file=video)
-    
-    # Optional filtering by label name
-    label_name = request.GET.get('label')
-    if label_name:
-        try:
-            label = Label.objects.get(name=label_name)
-            queryset = queryset.filter(label=label)
-            logger.info(f"Filtering segments for video {pk} by label '{label_name}'")
-        except Label.DoesNotExist:
-            logger.warning(f"Label '{label_name}' not found, returning empty result")
-            return Response(
-                {'error': f"Label '{label_name}' not found"},
-                status=status.HTTP_404_NOT_FOUND
-            )
-    
-    # Order by start time for consistent results
-    segments = queryset.order_by('start_frame_number')
-    serializer = LabelVideoSegmentSerializer(segments, many=True)
-    
-    logger.info(f"Returning {len(segments)} segments for video {pk}")
-    return Response(serializer.data)