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

endoreg_db/views/media/segments.py

@@ -0,0 +1,71 @@
+"""
+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)

endoreg_db/views/media/sensitive_metadata.py

@@ -0,0 +1,314 @@
+# Modern Media Framework: Sensitive Metadata Management
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.response import Response
+from rest_framework import status
+from django.db import transaction
+from django.db.models import Q
+from django.shortcuts import get_object_or_404
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+from endoreg_db.models import VideoFile, RawPdfFile, SensitiveMeta
+from endoreg_db.serializers.meta import (
+    SensitiveMetaDetailSerializer,
+    SensitiveMetaUpdateSerializer,
+)
+
+# === VIDEO SENSITIVE METADATA ===
+
+@api_view(['GET', 'PATCH'])
+@permission_classes([EnvironmentAwarePermission])
+def video_sensitive_metadata(request, pk):
+    """
+    GET /api/media/videos/<pk>/sensitive-metadata/
+    PATCH /api/media/videos/<pk>/sensitive-metadata/
+    
+    Get or update sensitive metadata for a video.
+    Video-scoped: Uses video ID to locate related sensitive metadata.
+    """
+    video = get_object_or_404(VideoFile, pk=pk)
+    
+    # Get related sensitive metadata
+    if not video.sensitive_meta:
+        return Response(
+            {"error": f"No sensitive metadata found for video {pk}"},
+            status=status.HTTP_404_NOT_FOUND
+        )
+    
+    sensitive_meta = video.sensitive_meta
+    
+    if request.method == 'GET':
+        serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+    
+    elif request.method == 'PATCH':
+        serializer = SensitiveMetaUpdateSerializer(
+            sensitive_meta,
+            data=request.data,
+            partial=True
+        )
+        
+        if serializer.is_valid():
+            updated_instance = serializer.save()
+            response_serializer = SensitiveMetaDetailSerializer(updated_instance)
+            
+            return Response({
+                "message": "Sensitive metadata updated successfully",
+                "sensitive_meta": response_serializer.data,
+                "video_id": pk
+            }, status=status.HTTP_200_OK)
+        
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['POST'])
+@permission_classes([EnvironmentAwarePermission])
+@transaction.atomic
+def video_sensitive_metadata_verify(request, pk):
+    """
+    POST /api/media/videos/<pk>/sensitive-metadata/verify/
+    
+    Update verification state for video sensitive metadata.
+    
+    Expected payload:
+    {
+        "dob_verified": true,
+        "names_verified": true
+    }
+    """
+    video = get_object_or_404(VideoFile, pk=pk)
+    
+    if not video.sensitive_meta:
+        return Response(
+            {"error": f"No sensitive metadata found for video {pk}"},
+            status=status.HTTP_404_NOT_FOUND
+        )
+    
+    sensitive_meta = video.sensitive_meta
+    
+    dob_verified = request.data.get('dob_verified')
+    names_verified = request.data.get('names_verified')
+    
+    if dob_verified is None and names_verified is None:
+        return Response(
+            {"error": "At least one of dob_verified or names_verified must be provided"},
+            status=status.HTTP_400_BAD_REQUEST
+        )
+    
+    state = sensitive_meta.get_or_create_state()
+    
+    if dob_verified is not None:
+        state.dob_verified = dob_verified
+    if names_verified is not None:
+        state.names_verified = names_verified
+    
+    state.save()
+    
+    response_serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+    return Response({
+        "message": "Verification state updated successfully",
+        "sensitive_meta": response_serializer.data,
+        "video_id": pk,
+        "state_verified": state.is_verified
+    }, status=status.HTTP_200_OK)
+
+
+# === PDF SENSITIVE METADATA ===
+
+@api_view(['GET', 'PATCH'])
+@permission_classes([EnvironmentAwarePermission])
+def pdf_sensitive_metadata(request, pk):
+    """
+    GET /api/media/pdfs/<pk>/sensitive-metadata/
+    PATCH /api/media/pdfs/<pk>/sensitive-metadata/
+    
+    Get or update sensitive metadata for a PDF.
+    PDF-scoped: Uses PDF ID to locate related sensitive metadata.
+    """
+    pdf = get_object_or_404(RawPdfFile, pk=pk)
+    
+    # Get related sensitive metadata
+    if not pdf.sensitive_meta:
+        return Response(
+            {"error": f"No sensitive metadata found for PDF {pk}"},
+            status=status.HTTP_404_NOT_FOUND
+        )
+    
+    sensitive_meta = pdf.sensitive_meta
+    
+    if request.method == 'GET':
+        serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+        return Response(serializer.data, status=status.HTTP_200_OK)
+    
+    elif request.method == 'PATCH':
+        serializer = SensitiveMetaUpdateSerializer(
+            sensitive_meta,
+            data=request.data,
+            partial=True
+        )
+        
+        if serializer.is_valid():
+            updated_instance = serializer.save()
+            response_serializer = SensitiveMetaDetailSerializer(updated_instance)
+            
+            return Response({
+                "message": "Sensitive metadata updated successfully",
+                "sensitive_meta": response_serializer.data,
+                "pdf_id": pk
+            }, status=status.HTTP_200_OK)
+        
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['POST'])
+@permission_classes([EnvironmentAwarePermission])
+@transaction.atomic
+def pdf_sensitive_metadata_verify(request, pk):
+    """
+    POST /api/media/pdfs/<pk>/sensitive-metadata/verify/
+    
+    Update verification state for PDF sensitive metadata.
+    
+    Expected payload:
+    {
+        "dob_verified": true,
+        "names_verified": true
+    }
+    """
+    pdf = get_object_or_404(RawPdfFile, pk=pk)
+    
+    if not pdf.sensitive_meta:
+        return Response(
+            {"error": f"No sensitive metadata found for PDF {pk}"},
+            status=status.HTTP_404_NOT_FOUND
+        )
+    
+    sensitive_meta = pdf.sensitive_meta
+    
+    dob_verified = request.data.get('dob_verified')
+    names_verified = request.data.get('names_verified')
+    
+    if dob_verified is None and names_verified is None:
+        return Response(
+            {"error": "At least one of dob_verified or names_verified must be provided"},
+            status=status.HTTP_400_BAD_REQUEST
+        )
+    
+    state = sensitive_meta.get_or_create_state()
+    
+    if dob_verified is not None:
+        state.dob_verified = dob_verified
+    if names_verified is not None:
+        state.names_verified = names_verified
+    
+    state.save()
+    
+    response_serializer = SensitiveMetaDetailSerializer(sensitive_meta)
+    return Response({
+        "message": "Verification state updated successfully",
+        "sensitive_meta": response_serializer.data,
+        "pdf_id": pk,
+        "state_verified": state.is_verified
+    }, status=status.HTTP_200_OK)
+
+
+# === LIST ENDPOINTS (Collection-Level) ===
+
+@api_view(['GET'])
+@permission_classes([EnvironmentAwarePermission])
+def sensitive_metadata_list(request):
+    """
+    GET /api/media/sensitive-metadata/
+    
+    List all sensitive metadata (combined PDFs and Videos).
+    Supports filtering by content_type, status, etc.
+    
+    Query parameters:
+    - content_type: 'pdf' | 'video' (optional)
+    - verified: Filter by verification status
+    - ordering: Sort field
+    - search: Search in patient names
+    """
+    from endoreg_db.serializers.meta import SensitiveMetaDetailSerializer
+    
+    # Get all sensitive metadata
+    queryset = SensitiveMeta.objects.select_related('state').all()
+    
+    # Filter by content type
+    content_type = request.query_params.get('content_type')
+    if content_type == 'pdf':
+        # Only PDFs - filter by existence of related PDFs
+        queryset = queryset.filter(raw_pdf_files__isnull=False).distinct()
+    elif content_type == 'video':
+        # Only Videos - filter by existence of related video
+        queryset = queryset.filter(video_file__isnull=False).distinct()
+    
+    # Filter by verification status
+    verified = request.query_params.get('verified')
+    if verified is not None:
+        verified_bool = verified.lower() in ('true', '1', 'yes')
+        queryset = queryset.filter(state__is_verified=verified_bool)
+    
+    # Search in patient names
+    search = request.query_params.get('search')
+    if search:
+        queryset = queryset.filter(
+            Q(patient_first_name__icontains=search) |
+            Q(patient_last_name__icontains=search)
+        )
+    
+    # Ordering
+    ordering = request.query_params.get('ordering', '-id')
+    queryset = queryset.order_by(ordering)
+    
+    # Pagination
+    from rest_framework.pagination import PageNumberPagination
+    paginator = PageNumberPagination()
+    paginator.page_size = 20
+    page = paginator.paginate_queryset(queryset, request)
+    
+    if page is not None:
+        serializer = SensitiveMetaDetailSerializer(page, many=True)
+        return paginator.get_paginated_response(serializer.data)
+    
+    serializer = SensitiveMetaDetailSerializer(queryset, many=True)
+    return Response(serializer.data, status=status.HTTP_200_OK)
+
+
+@api_view(['GET'])
+@permission_classes([EnvironmentAwarePermission])
+def pdf_sensitive_metadata_list(request):
+    """
+    GET /api/media/pdfs/sensitive-metadata/
+    
+    List sensitive metadata for PDFs only.
+    Replaces legacy /api/pdf/sensitivemeta/list/
+    """
+    from endoreg_db.serializers.meta import SensitiveMetaDetailSerializer
+    
+    # Get all PDFs with sensitive metadata
+    queryset = SensitiveMeta.objects.select_related('state').filter(
+        raw_pdf_files__isnull=False
+    ).distinct()
+    
+    # Apply filters
+    search = request.query_params.get('search')
+    if search:
+        queryset = queryset.filter(
+            Q(patient_first_name__icontains=search) |
+            Q(patient_last_name__icontains=search)
+        )
+    
+    ordering = request.query_params.get('ordering', '-id')
+    queryset = queryset.order_by(ordering)
+    
+    # Pagination
+    from rest_framework.pagination import PageNumberPagination
+    paginator = PageNumberPagination()
+    paginator.page_size = 20
+    page = paginator.paginate_queryset(queryset, request)
+    
+    if page is not None:
+        serializer = SensitiveMetaDetailSerializer(page, many=True)
+        return paginator.get_paginated_response(serializer.data)
+    
+    serializer = SensitiveMetaDetailSerializer(queryset, many=True)
+    return Response(serializer.data, status=status.HTTP_200_OK)

endoreg_db/views/media/video_media.py

@@ -0,0 +1,272 @@
+"""
+Video Media Management View (Phase 1.2)
+
+Provides CRUD operations for video files including listing, detail retrieval,
+and metadata management for the media management system.
+
+This complements VideoStreamView which handles the actual video streaming.
+"""
+
+import logging
+from django.http import Http404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+from django.db.models import Q
+
+from endoreg_db.models import VideoFile
+from endoreg_db.serializers.video.video_file_list import VideoFileListSerializer
+from endoreg_db.serializers.video.video_file_detail import VideoDetailSerializer
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+logger = logging.getLogger(__name__)
+
+
+class VideoMediaView(APIView):
+    """
+    Video Media Management API for CRUD operations on video files.
+    
+    Endpoints:
+    - GET /api/media/videos/ - List all videos with filtering
+    - GET /api/media/videos/{id}/ - Get video details
+    - PATCH /api/media/videos/{id}/ - Update video metadata (future)
+    - DELETE /api/media/videos/{id}/ - Delete video 
+    
+    Query Parameters:
+    - status: Filter by processing status (not_started, processing, done, failed, validated)
+    - search: Search in filename
+    - limit: Limit results (default: 50)
+    - offset: Pagination offset
+    
+    Examples:
+    - GET /api/media/videos/?status=done&search=exam
+    - GET /api/media/videos/123/
+    
+    Phase 1.2 Implementation:
+    - List and detail views implemented
+    - Filtering and search functionality
+    - Pagination support
+    - Error handling with proper HTTP status codes
+    - Integration with existing serializers
+    """
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, pk=None):
+        """
+        Handle GET requests for video listing or detail retrieval.
+        
+        Args:
+            request: HTTP request object
+            pk: Optional video ID for detail view
+            
+        Returns:
+            Response: JSON response with video data or list
+            
+        Raises:
+            Http404: If specific video not found
+        """
+        if pk is not None:
+            # Detail view
+            return self._get_video_detail(pk)
+        else:
+            # List view
+            return self._list_videos(request)
+
+    def _get_video_detail(self, pk):
+        """
+        Get detailed information for a specific video.
+        
+        Args:
+            pk: Video primary key
+            
+        Returns:
+            Response: JSON response with video details
+            
+        Raises:
+            Http404: If video not found
+        """
+        try:
+            # Validate video_id is numeric
+            try:
+                video_id_int = int(pk)
+            except (ValueError, TypeError):
+                raise Http404("Invalid video ID format")
+                
+            # Fetch video with related data
+            video = VideoFile.objects.select_related(
+                'state', 'sensitive_meta'
+            ).get(pk=video_id_int)
+            
+            # Serialize with request context for URL generation
+            serializer = VideoDetailSerializer(video, context={'request': self.request})
+            
+            return Response(serializer.data)
+            
+        except VideoFile.DoesNotExist:
+            raise Http404(f"Video with ID {pk} not found")
+            
+        except Exception as e:
+            logger.error(f"Unexpected error in video detail view for ID {pk}: {str(e)}")
+            return Response(
+                {"error": "Failed to retrieve video details"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def _list_videos(self, request):
+        """
+        List videos with filtering, search, and pagination.
+        
+        Args:
+            request: HTTP request with query parameters
+            
+        Returns:
+            Response: JSON response with paginated video list
+        """
+        try:
+            # Start with all videos
+            queryset = VideoFile.objects.select_related('state', 'sensitive_meta').all()
+            
+            # Apply filters
+            queryset = self._apply_filters(queryset, request.query_params)
+            
+            # Apply search
+            search = request.query_params.get('search', '').strip()
+            if search:
+                queryset = queryset.filter(
+                    Q(original_file_name__icontains=search)
+                )
+            
+            # Order by upload date (newest first)
+            queryset = queryset.order_by('-uploaded_at')
+            
+            # Apply pagination
+            limit = min(int(request.query_params.get('limit', 50)), 100)
+            offset = int(request.query_params.get('offset', 0))
+            
+            total_count = queryset.count()
+            videos = queryset[offset:offset + limit]
+            
+            # Serialize
+            serializer = VideoFileListSerializer(videos, many=True)
+            
+            return Response({
+                "count": total_count,
+                "next": self._get_next_url(request, offset, limit, total_count),
+                "previous": self._get_previous_url(request, offset, limit),
+                "results": serializer.data
+            })
+            
+        except ValueError as e:
+            return Response(
+                {"error": f"Invalid query parameter: {str(e)}"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+            
+        except Exception as e:
+            logger.error(f"Unexpected error in video list view: {str(e)}")
+            return Response(
+                {"error": "Failed to retrieve video list"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+
+    def _apply_filters(self, queryset, query_params):
+        """
+        Apply status and other filters to video queryset.
+        
+        Args:
+            queryset: Base queryset to filter
+            query_params: Request query parameters
+            
+        Returns:
+            QuerySet: Filtered queryset
+        """
+        status_filter = query_params.get('status', '').strip().lower()
+        
+        if status_filter:
+            if status_filter == 'not_started':
+                # Videos without state or with not_started status
+                queryset = queryset.filter(
+                    Q(state__isnull=True) | 
+                    Q(state__frames_extracted=False, state__sensitive_meta_processed=False)
+                )
+            elif status_filter == 'processing':
+                # Videos in any processing state
+                queryset = queryset.filter(
+                    state__frames_extracted=True,
+                    state__sensitive_meta_processed=False
+                )
+            elif status_filter == 'done':
+                # Videos with anonymization complete but not validated
+                queryset = queryset.filter(
+                    state__anonymized=True,
+                    sensitive_meta__is_verified=False
+                )
+            elif status_filter == 'validated':
+                # Videos with human validation complete
+                queryset = queryset.filter(
+                    state__anonymized=True,
+                    sensitive_meta__is_verified=True
+                )
+            elif status_filter == 'failed':
+                # Failed videos (this might need adjustment based on actual failure tracking)
+                queryset = queryset.filter(
+                    state__isnull=False,
+                    state__frames_extracted=False,
+                    state__sensitive_meta_processed=False
+                )
+                
+        return queryset
+
+    def _get_next_url(self, request, offset, limit, total_count):
+        """Generate next page URL for pagination."""
+        if offset + limit >= total_count:
+            return None
+            
+        next_offset = offset + limit
+        return self._build_paginated_url(request, next_offset, limit)
+
+    def _get_previous_url(self, request, offset, limit):
+        """Generate previous page URL for pagination."""
+        if offset <= 0:
+            return None
+            
+        prev_offset = max(0, offset - limit)
+        return self._build_paginated_url(request, prev_offset, limit)
+
+    def _build_paginated_url(self, request, offset, limit):
+        """Build URL with pagination parameters."""
+        params = request.query_params.copy()
+        params['offset'] = offset
+        params['limit'] = limit
+        
+        base_url = request.build_absolute_uri(request.path)
+        if params:
+            return f"{base_url}?{params.urlencode()}"
+        return base_url
+
+    # Future implementation placeholders
+    def patch(self, request, pk):
+        """
+        Update video metadata (Phase 1.2+ future enhancement).
+        
+        Currently returns 501 Not Implemented.
+        """
+        return Response(
+            {"error": "Video metadata updates not yet implemented"},
+            status=status.HTTP_501_NOT_IMPLEMENTED
+        )
+
+    def delete(self, request, pk):
+        """
+        Delete video file (Phase 1.2+ future enhancement).
+        
+        Currently returns 501 Not Implemented.
+        Use /api/media-management/force-remove/{id}/ instead.
+        """
+        return Response(
+            {
+                "error": "Video deletion not yet implemented", 
+                "alternative": f"Use DELETE /api/media-management/force-remove/{pk}/ instead"
+            },
+            status=status.HTTP_501_NOT_IMPLEMENTED
+        )