endoreg-db 0.8.5.1__py3-none-any.whl

endoreg_db/views/video/video_correction.py

@@ -0,0 +1,21 @@
+from endoreg_db.models import VideoFile
+from endoreg_db.serializers.video.video_file_detail import VideoDetailSerializer
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+class VideoCorrectionView(APIView):
+    """
+    GET /api/video/media/video-correction/{id}/ - Get video details for correction
+    """
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, pk):
+        video = get_object_or_404(VideoFile, pk=pk)
+        ser = VideoDetailSerializer(video, context={"request": request})
+        return Response(ser.data, status=status.HTTP_200_OK)

endoreg_db/views/video/video_download_processed.py

@@ -0,0 +1,58 @@
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+import os
+
+
+class VideoDownloadProcessedView(APIView):
+    """
+    GET /api/video-download-processed/{id}/ - Download processed video result
+    """
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, pk):
+        # Remove unused 'video' variable
+        output_path = request.query_params.get('path')
+
+        # Define the allowed base directory for processed videos
+        processed_base_dir = os.path.abspath(os.getenv("PROCESSED_VIDEO_DIR", "/srv/processed_videos"))
+        if not output_path:
+            return Response(
+                {"error": "Processed file not found"},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        # Resolve the absolute path and check if it's within the allowed directory
+        abs_output_path = os.path.abspath(output_path)
+        if not abs_output_path.startswith(processed_base_dir + os.sep):
+            return Response(
+                {"error": "Invalid file path"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        if not os.path.exists(abs_output_path):
+            return Response(
+                {"error": "Processed file not found"},
+                status=status.HTTP_404_NOT_FOUND
+            )
+
+        try:
+            from django.http import FileResponse
+            with open(abs_output_path, 'rb') as f:
+                response = FileResponse(
+                    f,
+                    content_type='video/mp4'
+                )
+                response['Content-Disposition'] = f'attachment; filename="{os.path.basename(abs_output_path)}"'
+                return response
+
+        except Exception as e:
+            return Response(
+                {"error": f"Failed to serve file: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )

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_media.py

@@ -0,0 +1,158 @@
+from endoreg_db.models import SensitiveMeta, VideoFile
+from endoreg_db.serializers import SensitiveMetaUpdateSerializer
+from endoreg_db.serializers.video.video_file_detail import VideoDetailSerializer
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+from endoreg_db.views.video.segmentation import _stream_video_file
+
+
+from django.db import transaction
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+import os
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+class VideoMediaView(APIView):
+    """
+    One endpoint that does
+      GET /api/media/videos/          →   next video meta
+      GET /api/media/videos/?last_id=7
+      GET /api/media/videos/42/       →   meta for id 42
+      GET /api/media/videos/42/  (Accept≠JSON)  →  byte‐range stream
+      PATCH /api/media/videos/42/     →   update sensitive meta and handle raw file deletion
+    """
+    permission_classes = [EnvironmentAwarePermission]
+
+    # ---------- GET ----------
+    def get(self, request, pk=None):
+        # Prüfe explizit auf Streaming-Anfrage via Query-Parameter
+        wants_stream = request.query_params.get("stream") is not None or request.query_params.get("type") is not None
+        
+        if pk and wants_stream:                                    # STREAM
+            vf = get_object_or_404(VideoFile, pk=pk)
+            file_type = (request.query_params.get("type") or "auto").lower()
+            
+                
+            return _stream_video_file(
+                vf,
+                os.getenv("FRONTEND_ORIGIN", "*"),
+                file_type
+            )
+
+        # META (list or single) - nur wenn kein Streaming gewünscht
+        if pk:                                                     # detail JSON
+            vf = get_object_or_404(VideoFile, pk=pk)
+        else:
+            last_id = request.query_params.get("last_id")
+            if last_id is not None:
+                try:
+                    last_id = int(last_id)
+                except (ValueError, TypeError):
+                    return Response(
+                        {"error": "Invalid last_id parameter"},
+                        status=status.HTTP_400_BAD_REQUEST
+                    )
+            vf = VideoFile.objects.next_after(last_id)
+            if not vf:
+                return Response({"error": "No more videos"}, status=404)
+
+        ser = VideoDetailSerializer(vf, context={"request": request})
+        return Response(ser.data, status=status.HTTP_200_OK)
+
+    # ---------- PATCH ----------
+    @transaction.atomic
+    def patch(self, request, pk=None):
+        sm_id = request.data.get("sensitive_meta_id")
+        if not sm_id:
+            return Response(
+                {"error": "sensitive_meta_id is required"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+        try:
+            sm_id = int(sm_id)
+        except (ValueError, TypeError):
+            return Response(
+                {"error": "Invalid sensitive_meta_id"},
+                status=status.HTTP_400_BAD_REQUEST
+            )
+
+        sm = get_object_or_404(SensitiveMeta, pk=sm_id)
+
+        # Check if this is a validation acceptance (is_verified being set to True)
+        is_accepting_validation = request.data.get("is_verified", False)
+        delete_raw_files = request.data.get("delete_raw_files", False)
+
+        # If user is accepting validation, automatically set delete_raw_files to True
+        if is_accepting_validation:
+            delete_raw_files = True
+            logger.info(f"Validation accepted for SensitiveMeta {sm_id}, marking raw files for deletion")
+
+        ser = SensitiveMetaUpdateSerializer(sm, data=request.data, partial=True)
+        ser.is_valid(raise_exception=True)
+        updated_sm = ser.save()
+
+        # Handle raw file deletion if requested or if validation was accepted
+        if delete_raw_files and updated_sm.is_verified:
+            try:
+                # Find associated video file
+                video_file = VideoFile.objects.filter(sensitive_meta=updated_sm).first()
+                if video_file:
+                    self._schedule_raw_file_deletion(video_file)
+                    logger.info(f"Scheduled raw file deletion for video {video_file.uuid}")
+                else:
+                    logger.warning(f"No video file found for SensitiveMeta {sm_id}")
+            except Exception as e:
+                logger.error(f"Error scheduling raw file deletion for SensitiveMeta {sm_id}: {e}")
+                # Don't fail the entire request if deletion scheduling fails
+
+        return Response(ser.data, status=status.HTTP_200_OK)
+
+    def _schedule_raw_file_deletion(self, video_file):
+        """
+        Schedule deletion of raw video file after validation acceptance.
+        Uses the existing cleanup mechanism from the anonymization pipeline.
+        """
+        try:
+            # Import here to avoid circular imports
+            from django.db import transaction
+
+            def cleanup_raw_files():
+                """Cleanup function to be called after transaction commit"""
+                try:
+                    if hasattr(video_file, 'raw_video_file') and video_file.raw_video_file:
+                        raw_file = video_file.raw_video_file
+                        if raw_file.file and os.path.exists(raw_file.file.path):
+                            logger.info(f"Deleting raw video file: {raw_file.file.path}")
+                            os.remove(raw_file.file.path)
+                            raw_file.file = None
+                            raw_file.save()
+                            logger.info(f"Successfully deleted raw video file for video {video_file.uuid}")
+                        else:
+                            logger.info(f"Raw video file already deleted or not found for video {video_file.uuid}")
+                    else:
+                        logger.info(f"No raw video file found for video {video_file.uuid}")
+
+                    # Also delete any associated raw frames if they exist
+                    if hasattr(video_file, 'raw_frames_dir'):
+                        frames_dir = getattr(video_file, 'raw_frames_dir', None)
+                        if frames_dir and os.path.exists(frames_dir):
+                            import shutil
+                            logger.info(f"Deleting raw frames directory: {frames_dir}")
+                            shutil.rmtree(frames_dir)
+                            logger.info(f"Successfully deleted raw frames for video {video_file.uuid}")
+
+                except Exception as e:
+                    logger.error(f"Error during raw file cleanup for video {video_file.uuid}: {e}")
+
+            # Schedule cleanup after transaction commits
+            transaction.on_commit(cleanup_raw_files)
+
+        except Exception as e:
+            logger.error(f"Error scheduling raw file deletion for video {video_file.uuid}: {e}")
+            raise

endoreg_db/views/video/video_meta.py

@@ -0,0 +1,29 @@
+from endoreg_db.models import VideoFile
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+class VideoMetadataView(APIView):
+    """
+    GET /api/video-metadata/{id}/ - Get video metadata including sensitivity analysis
+    """
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, pk):
+        video = get_object_or_404(VideoFile, pk=pk)
+
+        # Get or calculate metadata
+        metadata = {
+            'sensitiveFrameCount': getattr(video, 'sensitive_frame_count', None),
+            'totalFrames': getattr(video, 'total_frames', None),
+            'sensitiveRatio': getattr(video, 'sensitive_ratio', None),
+            'duration': getattr(video, 'duration', None),
+            'resolution': getattr(video, 'resolution', None),
+        }
+
+        return Response(metadata, status=status.HTTP_200_OK)

endoreg_db/views/video/video_processing_history.py

@@ -0,0 +1,24 @@
+from endoreg_db.models import VideoFile
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+class VideoProcessingHistoryView(APIView):
+    """
+    GET /api/video-processing-history/{id}/ - Get processing history for a video
+    """
+    permission_classes = [EnvironmentAwarePermission]
+
+    def get(self, request, pk):
+        _video = get_object_or_404(VideoFile, pk=pk)
+
+        # For now, return empty history - can be extended with actual history tracking
+        #TODO plan when to implement this
+        history = []
+
+        return Response(history, status=status.HTTP_200_OK)

endoreg_db/views/video/video_remove_frames.py

@@ -0,0 +1,48 @@
+from endoreg_db.models import VideoFile
+from endoreg_db.utils.permissions import EnvironmentAwarePermission
+
+
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.response import Response
+from rest_framework.views import APIView
+
+
+class VideoRemoveFramesView(APIView):
+    """
+    POST /api/video-remove-frames/{id}/ - Remove frames from video using streaming processing
+    """
+    permission_classes = [EnvironmentAwarePermission]
+
+    def post(self, request, pk):
+        video = get_object_or_404(VideoFile, pk=pk)
+
+        selection_method = request.data.get('selection_method', 'automatic')
+        detection_engine = request.data.get('detection_engine', 'minicpm')
+        use_streaming = request.data.get('use_streaming', True)
+        manual_frames = request.data.get('manual_frames')
+
+        try:
+            # Start async task for frame removal
+            from endoreg_db.tasks.video_processing_tasks import remove_video_frames_task
+
+            task_data = {
+                'video_id': pk,
+                'selection_method': selection_method,
+                'detection_engine': detection_engine,
+                'use_streaming': use_streaming,
+                'manual_frames': manual_frames
+            }
+
+            task = remove_video_frames_task.delay(**task_data)
+
+            return Response(
+                {"task_id": task.id, "status": "started"},
+                status=status.HTTP_202_ACCEPTED
+            )
+
+        except Exception as e:
+            return Response(
+                {"error": f"Failed to start frame removal task: {str(e)}"},
+                status=status.HTTP_500_INTERNAL_SERVER_ERROR
+            )