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

endoreg_db/views/video/video_examination_viewset.py

@@ -0,0 +1,329 @@
+# endoreg_db/views/examination_views.py
+from rest_framework.viewsets import ModelViewSet
+from rest_framework import status
+from rest_framework.decorators import api_view
+from rest_framework.response import Response
+from django.shortcuts import get_object_or_404
+from rest_framework import viewsets
+
+from endoreg_db.models import (
+    Examination, 
+    VideoFile,
+    FindingClassification,
+    FindingClassificationChoice,
+    FindingIntervention,
+    Finding
+)
+from ...serializers.examination import (
+    ExaminationSerializer as ExaminationSerializer,
+    # FindingSerializer as FindingSerializer,
+)
+
+
+class ExaminationViewSet(ModelViewSet):
+    queryset = Examination.objects.all()
+    serializer_class = ExaminationSerializer
+
+
+# NEW: Video Examination CRUD ViewSet
+class VideoExaminationViewSet(viewsets.ModelViewSet):
+    """
+    ViewSet for Video Examination CRUD operations
+    Handles POST and PATCH for video examinations at timestamps
+    """
+    
+    def get_queryset(self):
+        # Return empty queryset as we handle retrieval manually
+        return []
+    
+    def create(self, request, *args, **kwargs):
+        """
+        Create a new video examination
+        POST /api/examinations/
+        
+        Expected payload:
+        {
+            "videoId": 123,
+            "timestamp": 45.5,
+            "examinationTypeId": 1,
+            "findingId": 2,
+            "locationClassificationId": 3,
+            "locationChoiceId": 4,
+            "morphologyClassificationId": 5,
+            "morphologyChoiceId": 6,
+            "interventionIds": [7, 8],
+            "notes": "Sample notes"
+        }
+        """
+        from django.db import transaction
+        import logging
+        
+        logger = logging.getLogger(__name__)
+        
+        try:
+            data = request.data
+            
+            # Validate required fields
+            required_fields = ['videoId', 'timestamp', 'examinationTypeId', 'findingId']
+            for field in required_fields:
+                if field not in data or data[field] is None:
+                    return Response(
+                        {'error': f'Missing or null required field: {field}'}, 
+                        status=status.HTTP_400_BAD_REQUEST
+                    )
+            
+            # Validate data types
+            try:
+                video_id = int(data['videoId'])
+                timestamp = float(data['timestamp'])
+                examination_type_id = int(data['examinationTypeId'])
+                finding_id = int(data['findingId'])
+            except (ValueError, TypeError) as e:
+                return Response(
+                    {'error': f'Invalid data type in request: {str(e)}'}, 
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+            
+            # Validate timestamp is not negative
+            if timestamp < 0:
+                return Response(
+                    {'error': 'Timestamp cannot be negative'}, 
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+            
+            with transaction.atomic():
+                # Get video
+                try:
+                    video = VideoFile.objects.get(id=video_id)
+                except VideoFile.DoesNotExist:
+                    return Response(
+                        {'error': 'Video not found'}, 
+                        status=status.HTTP_404_NOT_FOUND
+                    )
+                
+                # Get examination type
+                try:
+                    examination = Examination.objects.get(id=examination_type_id)
+                except Examination.DoesNotExist:
+                    return Response(
+                        {'error': 'Examination type not found'}, 
+                        status=status.HTTP_404_NOT_FOUND
+                    )
+                
+                # Get finding
+                try:
+                    finding = Finding.objects.get(id=finding_id)
+                except Finding.DoesNotExist:
+                    return Response(
+                        {'error': 'Finding not found'}, 
+                        status=status.HTTP_404_NOT_FOUND
+                    )
+                
+                # Validate optional foreign keys if provided
+                if data.get('locationClassificationId'):
+                    try:
+                        FindingClassification.objects.get(id=data['locationClassificationId'], classification_types__name__iexact="location")
+                    except FindingClassification.DoesNotExist:
+                        return Response(
+                            {'error': 'Location classification not found'}, 
+                            status=status.HTTP_404_NOT_FOUND
+                        )
+                
+                if data.get('morphologyClassificationId'):
+                    try:
+                        FindingClassification.objects.get(
+                            id=data['morphologyClassificationId'],
+                            classification_types__name__iexact="morphology"
+                        )
+                    except FindingClassification.DoesNotExist:
+                        return Response(
+                            {'error': 'Morphology classification not found'}, 
+                            status=status.HTTP_404_NOT_FOUND
+                        )
+                
+                # Create examination record
+                examination_data = {
+                    'id': f"exam_{video.id}_{timestamp}_{examination.id}",
+                    'video_id': video_id,
+                    'timestamp': timestamp,
+                    'examination_type': examination.name,
+                    'finding': finding.name,
+                    'location_classification': data.get('locationClassificationId'),
+                    'location_choice': data.get('locationChoiceId'),
+                    'morphology_classification': data.get('morphologyClassificationId'),
+                    'morphology_choice': data.get('morphologyChoiceId'),
+                    'interventions': data.get('interventionIds', []),
+                    'notes': data.get('notes', ''),
+                    'created_at': '2024-01-01T00:00:00Z'  # Placeholder timestamp
+                }
+                
+                logger.info(f"Created video examination for video {video_id} at timestamp {timestamp}")
+                return Response(examination_data, status=status.HTTP_201_CREATED)
+            
+        except Exception as e:
+            logger.error(f"Unexpected error creating examination: {str(e)}")
+            return Response(
+                {'error': 'Internal server error while creating examination'}, 
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+    
+    def update(self, request, *args, **kwargs):
+        """
+        Update an existing video examination
+        PATCH /api/examinations/{id}/
+        """
+        from django.db import transaction
+        import logging
+        
+        logger = logging.getLogger(__name__)
+        
+        try:
+            examination_id = kwargs.get('pk')
+            if not examination_id:
+                return Response(
+                    {'error': 'Examination ID is required'}, 
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+            
+            data = request.data
+            
+            # Validate data types for provided fields
+            if 'videoId' in data:
+                try:
+                    data['videoId'] = int(data['videoId'])
+                except (ValueError, TypeError):
+                    return Response(
+                        {'error': 'Invalid videoId format'}, 
+                        status=status.HTTP_400_BAD_REQUEST
+                    )
+            
+            if 'timestamp' in data:
+                try:
+                    timestamp = float(data['timestamp'])
+                    if timestamp < 0:
+                        return Response(
+                            {'error': 'Timestamp cannot be negative'}, 
+                            status=status.HTTP_400_BAD_REQUEST
+                        )
+                    data['timestamp'] = timestamp
+                except (ValueError, TypeError):
+                    return Response(
+                        {'error': 'Invalid timestamp format'}, 
+                        status=status.HTTP_400_BAD_REQUEST
+                    )
+            
+            with transaction.atomic():
+                # Validate foreign keys if provided
+                if 'videoId' in data:
+                    try:
+                        VideoFile.objects.get(id=data['videoId'])
+                    except VideoFile.DoesNotExist:
+                        return Response(
+                            {'error': 'Video not found'}, 
+                            status=status.HTTP_404_NOT_FOUND
+                        )
+                
+                if 'examinationTypeId' in data:
+                    try:
+                        examination_type_id = int(data['examinationTypeId'])
+                        Examination.objects.get(id=examination_type_id)
+                    except (ValueError, TypeError):
+                        return Response(
+                            {'error': 'Invalid examination type ID format'}, 
+                            status=status.HTTP_400_BAD_REQUEST
+                        )
+                    except Examination.DoesNotExist:
+                        return Response(
+                            {'error': 'Examination type not found'}, 
+                            status=status.HTTP_404_NOT_FOUND
+                        )
+                
+                if 'findingId' in data:
+                    try:
+                        finding_id = int(data['findingId'])
+                        Finding.objects.get(id=finding_id)
+                    except (ValueError, TypeError):
+                        return Response(
+                            {'error': 'Invalid finding ID format'}, 
+                            status=status.HTTP_400_BAD_REQUEST
+                        )
+                    except Finding.DoesNotExist:
+                        return Response(
+                            {'error': 'Finding not found'}, 
+                            status=status.HTTP_404_NOT_FOUND
+                        )
+                
+                # Return updated examination data
+                examination_data = {
+                    'id': examination_id,
+                    'video_id': data.get('videoId'),
+                    'timestamp': data.get('timestamp'),
+                    'examination_type': data.get('examinationTypeId'),
+                    'finding': data.get('findingId'),
+                    'location_classification': data.get('locationClassificationId'),
+                    'location_choice': data.get('locationChoiceId'),
+                    'morphology_classification': data.get('morphologyClassificationId'),
+                    'morphology_choice': data.get('morphologyChoiceId'),
+                    'interventions': data.get('interventionIds', []),
+                    'notes': data.get('notes', ''),
+                    'updated_at': '2024-01-01T00:00:00Z'  # Placeholder timestamp
+                }
+                
+                logger.info(f"Updated video examination {examination_id}")
+                return Response(examination_data, status=status.HTTP_200_OK)
+            
+        except Exception as e:
+            logger.error(f"Unexpected error updating examination {examination_id}: {str(e)}")
+            return Response(
+                {'error': 'Internal server error while updating examination'}, 
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )
+    
+    def destroy(self, request, *args, **kwargs):
+        """
+        Delete a video examination
+        DELETE /api/examinations/{id}/
+        """
+        from django.db import transaction
+        import logging
+        
+        logger = logging.getLogger(__name__)
+        
+        try:
+            examination_id = kwargs.get('pk')
+            if not examination_id:
+                return Response(
+                    {'error': 'Examination ID is required'}, 
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+            
+            # Validate examination_id format
+            try:
+                # For now, we're using string IDs, so just validate it's not empty
+                if not str(examination_id).strip():
+                    return Response(
+                        {'error': 'Invalid examination ID format'}, 
+                        status=status.HTTP_400_BAD_REQUEST
+                    )
+            except (ValueError, TypeError):
+                return Response(
+                    {'error': 'Invalid examination ID format'}, 
+                    status=status.HTTP_400_BAD_REQUEST
+                )
+            
+            with transaction.atomic():
+                # For now, we simulate successful deletion
+                # TODO: Implement actual examination record deletion when persistence is added
+                
+                logger.info(f"Deleted video examination {examination_id}")
+                return Response(
+                    {'message': f'Examination {examination_id} deleted successfully'}, 
+                    status=status.HTTP_204_NO_CONTENT
+                )
+            
+        except Exception as e:
+            logger.error(f"Unexpected error deleting examination {examination_id}: {str(e)}")
+            return Response(
+                {'error': 'Internal server error while deleting examination'}, 
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

endoreg_db/views/video/video_stream.py

@@ -0,0 +1,188 @@
+"""
+Video Streaming Views (Phase 3.2)
+
+Separate view for streaming raw and processed video files.
+Extracted from segmentation.py for better code organization.
+
+Created: October 9, 2025
+"""
+
+from pathlib import Path
+import os
+import mimetypes
+import logging
+from django.http import FileResponse, Http404
+from rest_framework.views import APIView
+
+from ...models import VideoFile
+from ...utils.permissions import EnvironmentAwarePermission
+
+logger = logging.getLogger(__name__)
+
+
+def _stream_video_file(vf: VideoFile, frontend_origin: str, file_type: str = 'raw') -> FileResponse:
+    """
+    Helper function to stream a video file with proper headers and CORS support.
+    
+    Args:
+        vf: VideoFile model instance
+        frontend_origin: Frontend origin URL for CORS headers
+        file_type: Either 'raw' (original video) or 'processed' (anonymized video)
+        
+    Returns:
+        FileResponse: HTTP response streaming the video file
+        
+    Raises:
+        Http404: If video file not found or cannot be accessed
+        
+    Note:
+        Permissions are handled by the calling view, not in this helper function.
+    """
+    try:
+        # Determine which file to stream based on file_type
+        if file_type == 'raw':
+            if hasattr(vf, 'active_raw_file') and vf.active_raw_file and hasattr(vf.active_raw_file, 'path'):
+                try:
+                    path = Path(vf.active_raw_file.path)
+                except (ValueError, AttributeError) as exc:
+                    raise Http404("No raw file associated with this video") from exc
+            else:
+                raise Http404("No raw video file available for this entry")
+            
+        elif file_type == 'processed':
+            if hasattr(vf, 'processed_file') and vf.processed_file and hasattr(vf.processed_file, 'path'):
+                try:
+                    path = Path(vf.processed_file.path)
+                except (ValueError, AttributeError) as exc:
+                    raise Http404("No processed file associated with this video") from exc
+            else:
+                raise Http404("No processed video file available for this entry")
+        else:
+            raise ValueError(f"Invalid file_type: {file_type}. Must be 'raw' or 'processed'.")
+        
+        # Validate file exists on disk
+        if not path.exists():
+            raise Http404(f"Video file not found on disk: {path}")
+
+        # Validate file size before streaming
+        try:
+            file_size = path.stat().st_size
+            if file_size == 0:
+                raise Http404("Video file is empty")
+        except OSError as e:
+            raise Http404(f"Cannot access video file: {str(e)}")
+
+        # Determine MIME type
+        mime, _ = mimetypes.guess_type(str(path))
+        content_type = mime or 'video/mp4'  # Default to mp4 if detection fails
+        
+        try:
+            # Open file in binary mode - FileResponse will handle closing
+            file_handle = open(path, 'rb')
+            response = FileResponse(file_handle, content_type=content_type)
+            
+            # Set HTTP headers for video streaming
+            response['Content-Length'] = str(file_size)
+            response['Accept-Ranges'] = 'bytes'  # Enable HTTP range requests for seeking
+            response['Content-Disposition'] = f'inline; filename="{path.name}"'
+            
+            # CORS headers for frontend access
+            response["Access-Control-Allow-Origin"] = frontend_origin
+            response["Access-Control-Allow-Credentials"] = "true"
+            
+            return response
+            
+        except IOError as e:
+            raise Http404(f"Cannot open video file: {str(e)}")
+            
+    except Exception as e:
+        # Log unexpected errors but don't expose internal details
+        logger.error(f"Unexpected error in _stream_video_file: {str(e)}")
+        raise Http404("Video file cannot be streamed")
+
+
+class VideoStreamView(APIView):
+    """
+    Separate view for video streaming to avoid DRF content negotiation issues.
+    
+    Supports streaming both raw (original) and processed (anonymized) videos.
+    
+    Query Parameters:
+        type: 'raw' (default) or 'processed' - Selects which video file to stream
+        file_type: (deprecated, use 'type') - Legacy parameter for backwards compatibility
+        
+    Examples:
+        GET /api/media/videos/1/?type=raw - Stream original raw video
+        GET /api/media/videos/1/?type=processed - Stream anonymized/masked video
+        GET /api/videostream/1/ - Default to raw video (legacy endpoint)
+        
+    Phase 3.2 Implementation:
+        - Supports dual video comparison (raw vs processed)
+        - Backward compatible with legacy ?file_type= parameter
+        - Proper error handling with Http404
+        - CORS support for frontend access
+        - HTTP range support for video seeking
+    """
+    permission_classes = [EnvironmentAwarePermission]
+    
+    def get(self, request, pk=None):
+        """
+        Stream raw or anonymized video file with HTTP range and CORS support.
+        
+        Args:
+            request: HTTP request object
+            pk: Video ID (primary key)
+            
+        Returns:
+            FileResponse: Streaming video file
+            
+        Raises:
+            Http404: If video not found or file cannot be accessed
+        """
+        if pk is None:
+            raise Http404("Video ID is required")
+            
+        try:
+            # Validate video_id is numeric
+            try:
+                video_id_int = int(pk)
+            except (ValueError, TypeError):
+                raise Http404("Invalid video ID format")
+            
+            # Support both 'type' (frontend standard) and 'file_type' (legacy)
+            # Priority: type > file_type > default 'raw'
+            try:
+                file_type: str = (
+                    request.query_params.get('type') or 
+                    request.query_params.get('file_type') or 
+                    'raw'
+                ).lower()
+                
+                if file_type not in ['raw', 'processed']:
+                    logger.warning(f"Invalid file_type '{file_type}', defaulting to 'raw'")
+                    file_type = 'raw'
+                    
+            except Exception as e:
+                logger.warning(f"Error parsing file_type parameter: {e}, defaulting to 'raw'")
+                file_type = 'raw'
+                            
+            # Fetch video from database
+            vf = VideoFile.objects.get(pk=video_id_int)
+            
+            # Get frontend origin for CORS
+            frontend_origin = os.environ.get('FRONTEND_ORIGIN', 'http://localhost:8000')
+            
+            # Stream the video file
+            return _stream_video_file(vf, frontend_origin, file_type)
+            
+        except VideoFile.DoesNotExist:
+            raise Http404(f"Video with ID {pk} not found")
+            
+        except Http404:
+            # Re-raise Http404 exceptions as they should bubble up
+            raise
+            
+        except Exception as e:
+            # Log unexpected errors and convert to Http404
+            logger.error(f"Unexpected error in VideoStreamView for video_id={pk}: {str(e)}")
+            raise Http404("Video streaming failed")